CN116414434A - Code branch construction method, electronic device and storage medium - Google Patents
Code branch construction method, electronic device and storage medium Download PDFInfo
- Publication number
- CN116414434A CN116414434A CN202111653617.XA CN202111653617A CN116414434A CN 116414434 A CN116414434 A CN 116414434A CN 202111653617 A CN202111653617 A CN 202111653617A CN 116414434 A CN116414434 A CN 116414434A
- Authority
- CN
- China
- Prior art keywords
- instruction
- branch
- external
- code
- requirement
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Pending
Links
- 238000010276 construction Methods 0.000 title claims abstract description 38
- 238000012360 testing method Methods 0.000 claims abstract description 18
- 238000011161 development Methods 0.000 claims description 15
- 238000004590 computer program Methods 0.000 claims description 10
- 238000000034 method Methods 0.000 abstract description 10
- 238000010586 diagram Methods 0.000 description 3
- 230000000694 effects Effects 0.000 description 3
- 230000006870 function Effects 0.000 description 2
- 238000012986 modification Methods 0.000 description 2
- 230000004048 modification Effects 0.000 description 2
- 238000003491 array Methods 0.000 description 1
- 238000004891 communication Methods 0.000 description 1
- 230000007547 defect Effects 0.000 description 1
- 238000005516 engineering process Methods 0.000 description 1
- 230000002708 enhancing effect Effects 0.000 description 1
- 230000003287 optical effect Effects 0.000 description 1
- 238000012545 processing Methods 0.000 description 1
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/70—Software maintenance or management
- G06F8/71—Version control; Configuration management
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/40—Transformation of program code
- G06F8/41—Compilation
- G06F8/43—Checking; Contextual analysis
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/40—Transformation of program code
- G06F8/41—Compilation
- G06F8/44—Encoding
- G06F8/443—Optimisation
-
- Y—GENERAL TAGGING OF NEW TECHNOLOGICAL DEVELOPMENTS; GENERAL TAGGING OF CROSS-SECTIONAL TECHNOLOGIES SPANNING OVER SEVERAL SECTIONS OF THE IPC; TECHNICAL SUBJECTS COVERED BY FORMER USPC CROSS-REFERENCE ART COLLECTIONS [XRACs] AND DIGESTS
- Y02—TECHNOLOGIES OR APPLICATIONS FOR MITIGATION OR ADAPTATION AGAINST CLIMATE CHANGE
- Y02D—CLIMATE CHANGE MITIGATION TECHNOLOGIES IN INFORMATION AND COMMUNICATION TECHNOLOGIES [ICT], I.E. INFORMATION AND COMMUNICATION TECHNOLOGIES AIMING AT THE REDUCTION OF THEIR OWN ENERGY USE
- Y02D10/00—Energy efficient computing, e.g. low power processors, power management or thermal management
Landscapes
- Engineering & Computer Science (AREA)
- General Engineering & Computer Science (AREA)
- Theoretical Computer Science (AREA)
- Software Systems (AREA)
- Physics & Mathematics (AREA)
- General Physics & Mathematics (AREA)
- Computer Security & Cryptography (AREA)
- Stored Programmes (AREA)
Abstract
The invention discloses a code branch construction method, electronic equipment and a storage medium. The code branch construction method comprises the following steps: acquiring an external instruction and identifying the external instruction; when the external instruction is a first instruction, copying the main branch to the functional branch for an external user to develop new characteristics based on the functional branch, wherein the first instruction is an instruction representing external requirements for developing the new characteristics; when the external instruction is a second instruction, combining the functional branches into the issuing branches for the external user to test or issue based on the issuing branches, wherein the second instruction is an instruction representing the requirement of the test; and when the external instruction is a third instruction, merging the issued branch into the main branch, wherein the third instruction is an instruction representing the requirement for code issuing, and returning to the step of acquiring the external instruction. The invention can effectively avoid the merging conflict in the code version management process by constructing the simplified code branches, and improve the accuracy and efficiency of the code version management.
Description
Technical Field
The present invention relates to the field of code branch construction technologies, and in particular, to a code branch construction method, an electronic device, and a storage medium.
Background
In the current software development process, the code is often version-managed using Git (an open-source distributed version control system). Git-flow (Git flow) includes several branches. As the number of workers on a branch increases, the number of merge conflicts that occur will increase substantially. In Git-flow, this number increases more because there are three other branches with different life cycles that are merged into the development: feature branching, issue branching, and emergency repair. The probability of a merge conflict occurring is not linearly variable, which may increase the probability of a merge conflict by a factor of three.
Disclosure of Invention
The invention aims to overcome the defect that merging conflicts easily occur in the process of carrying out version management on codes in the prior art, and provides a code branch construction method, electronic equipment and a storage medium.
The invention solves the technical problems by the following technical scheme:
the invention provides a code branch construction method, which comprises the following steps:
acquiring an external instruction and identifying the external instruction;
when the external instruction is a first instruction, copying the main branch to the functional branch for an external user to develop new characteristics based on the functional branch, wherein the first instruction is an instruction representing external requirements for developing the new characteristics;
when the external instruction is a second instruction, combining the functional branches into the issuing branches for the external user to test or issue based on the issuing branches, wherein the second instruction is an instruction representing the requirement of the test;
when the external instruction is a third instruction, merging the issuing branch into the main branch, wherein the third instruction is an instruction representing the requirement of code issuing;
returning to the step of fetching external instructions.
In the scheme, the merging conflict in the code version management process can be effectively avoided by constructing the simplified code branches, and the accuracy and the efficiency of the code version management are improved.
Preferably, the method further comprises:
when the external instruction is a fourth instruction, copying the main branch to the patch branch for an external user to repair the patch based on the patch branch, wherein the fourth instruction is an instruction for representing the requirement of repairing the patch;
when the external instruction is a fifth instruction, merging the patch branch into the main branch and merging the patch branch into the release branch, wherein the fifth instruction is an instruction representing the requirement of patch release;
returning to the step of fetching external instructions.
In the scheme, based on the construction of the patch branches, quick patch repair can be realized, and the code version release efficiency is improved.
Preferably, after merging the issue branches into the main branch, setting a corresponding version number for the main branch;
and/or after merging the patch branches into the main branch, setting a corresponding version number for the main branch.
In the scheme, the corresponding version number is set for the new stable version formed on the main branch, so that the orderly management of the version can be conveniently realized.
Preferably, functional branches are named based on hump naming rules.
In the scheme, the hump naming rule is based on naming the functional branches, so that the identifiability and the readability can be enhanced, and different users can read, recognize and understand the hump naming rule conveniently.
Preferably, the obtaining the external instruction includes:
and acquiring authority information and operation requirements of the external user to identify the external instruction.
In the scheme, through the management of the user authority, the construction and combination authorities of the corresponding code branches are distributed in a targeted manner, the code branches are prevented from being constructed and combined in an uncontrolled manner by multiple parties, the confusion of code combination can be reduced, and the code quality is improved by matching with the examination of submitted codes, so that the development is advanced in order.
Preferably, acquiring authority information and operation requirements of the external user to identify the external instruction includes:
if the authority information is of a first type of authority and the operation requirement is an external requirement for developing new characteristics, identifying an external instruction as a first instruction;
if the permission information is the second type permission and the operation requirement is the requirement of the test, identifying the external instruction as a second instruction;
if the permission information is the second type permission and the operation requirement is a requirement for code release, identifying the external instruction as a third instruction;
if the authority information is of a first type and the operation requirement is a requirement for patch repair, identifying an external instruction as a fourth instruction;
and if the authority information is the second type of authority and the operation requirement is the requirement for patch release, identifying the external instruction as a fifth instruction.
In the scheme, corresponding construction and combination authorities are correspondingly allocated for different code branches, so that confusion of code combination can be reduced, and development efficiency is improved.
Preferably, the first type of rights is development rights and the second type of rights is administrator rights.
In the scheme, corresponding construction and combination authorities are correspondingly allocated according to different attributes of the user, so that confusion of code combination can be reduced, and development efficiency is improved.
Preferably, after merging the issue branch into the main branch, the main branch is also set to a read-only state;
and/or after merging the patch branch into the main branch, the main branch is also set to a read-only state.
In the scheme, after a new stable version is formed on the main branch, the main branch is set to be in a read-only state, so that misoperation on the version of the main branch can be avoided.
The invention also provides an electronic device comprising a memory, a processor and a computer program stored on the memory and executable on the processor, the processor implementing the code branch construction method of the invention when executing the computer program.
The present invention also provides a computer-readable storage medium having stored thereon a computer program which, when executed by a processor, implements the code branch construction method of the present invention.
The invention has the positive progress effects that: the invention can effectively avoid the merging conflict in the code version management process by constructing the simplified code branches, and improve the accuracy and efficiency of the code version management.
Drawings
Fig. 1 is a flowchart of a code branch construction method of embodiment 1 of the present invention.
FIG. 2 is a flow chart of an alternative implementation of the code branch construction method of embodiment 1 of the present invention.
Fig. 3 is a schematic diagram of an application scenario of the code branch construction method of embodiment 1 of the present invention.
Fig. 4 is a schematic structural diagram of an electronic device according to embodiment 2 of the present invention.
Detailed Description
The invention is further illustrated by means of the following examples, which are not intended to limit the scope of the invention.
Example 1
The embodiment provides a code branch construction method. Referring to fig. 1, the code branch construction method includes the steps of:
and S0, acquiring an external instruction and identifying the external instruction. When the external instruction is the first instruction, executing step S1; when the external instruction is a second instruction, executing step S2; when the external instruction is the third instruction, step S3 is executed. The first instruction is an instruction for representing an external requirement for developing new characteristics, the second instruction is an instruction for representing a requirement for testing, and the third instruction is an instruction for representing a requirement for code issuing.
And S1, copying the main branch to the functional branch so as to enable an external user to develop new characteristics based on the functional branch.
And step S2, merging the functional branches into the release branches for the external user to test or release based on the release branches.
Step S3, merging the release branches to the main branches;
returning to step S0.
As an alternative embodiment, referring to fig. 2, the code branch construction method further includes:
when the external instruction is a fourth instruction, executing step S4; when the external instruction is the fifth instruction, step S5 is performed. The fourth instruction is an instruction characterizing a need for patch repair, and the fifth instruction is an instruction characterizing a need for patch release.
And S4, copying the main branch to a patch branch so as to enable an external user to repair the patch based on the patch branch.
And S5, merging the patch branches to the main branch and merging the patch branches to the release branch.
Fig. 3 shows an application scenario of version management based on the code branch construction method of the present embodiment, which is implemented based on a software development environment running on a computer (or server). The main branch is a stable branch, and the saved code version is the current stable version. Taking fig. 3 as an example, in the first node P1, in the initial state, the version number corresponding to the code version stored in the main branch is V1.0.0. At this time, if a new feature (feature) needs to be added to the code, the external user inputs a first instruction, which characterizes the external requirement for developing the new feature. Then, the code currently stored by the main branch is copied to the functional branch according to the first instruction input by the external user. In specific implementation, the obtaining the external instruction includes: and acquiring authority information and operation requirements of the external user to identify the external instruction. And if the authority information is the first type of authority and the operation requirement is an external requirement for developing a new characteristic, identifying the external instruction as a first instruction. The first type of rights are development rights, and the development rights are only opened to development responsible persons and development personnel. In specific implementation, whether the external user belongs to a development responsible person or developer is identified through an account number of the external user logging in the software development environment, so that whether the external user has the first type of authority is identified. That is, only the development responsible person and the developer have corresponding rights creation function branches.
As an alternative embodiment, when there are a plurality of external requirements for developing new characteristics, a corresponding functional branch is generated for each external requirement for developing new characteristics, respectively. Referring to fig. 3, for a first new feature, the code currently stored by the main branch with version number V1.0.0 is copied to the first functional branch F1; for the second new feature, the code currently held by the main branch with version number V1.0.0 is copied to the second functional branch F2.
Based on the first functional branch F1, the external user develops a first new feature. Based on the second functional branch F2, the external user develops a second new feature. In some alternative embodiments, functional branches are also named, wherein the naming convention employs hump naming conventions, thereby enhancing recognizability and readability for different users to read, recognize and understand.
Referring to fig. 3, if the need for patch repair occurs in the above process, the external user inputs a fourth instruction. According to the fourth instruction, the code with the version number V1.0.0 currently stored by the main branch is copied to the patch branch. The external user then performs patch repair based on the patch branches (e.g., patching the release version of the quick software product). As an optional implementation manner, the patch branch may be created only when the authority information corresponding to the external user is the first type of authority.
After the patch repair is completed, a fifth instruction, i.e., an instruction to perform the needs of the patch release, is generated. According to a fifth instruction, on the one hand, the code on the patch branch is merged into the main branch to form a new stable version, and the corresponding version number is set. That is, at the second node P2, a new stable version V1.0.1 is formed; on the other hand, the code on the patch branch is also merged into the release branch. In some alternative embodiments, the main branch is also set to a read-only state after merging the patch branch into the main branch.
In some alternative embodiments, if the rights information is a second type of rights and the operational requirement is a requirement for patch release, the external instruction is identified as a fifth instruction. The second type of rights is administrator rights, that is, the administrator has the right to merge the code on the patch branch into the release branch.
Referring to fig. 3, when the development of the second new characteristic corresponding to the second functional branch F2 is completed, a second instruction is generated to initiate the test, wherein the second instruction is an instruction characterizing the requirement of the test. The code on the second functional branch F2 is then merged into the issue branch according to the second instruction. The user then tests or publishes based on the publish branch. In the process of testing or publishing based on the publishing branch by the user, other functional branches cannot be combined to the publishing branch. That is, the first functional branch F1 may not merge into the issue branch after the second functional branch F2 merges into the issue branch, before the issue branch merges further into the main branch.
In some alternative embodiments, if the rights information is a second type of rights and the operational requirement is a requirement of a test, the external instruction is identified as a second instruction. Wherein the second type of rights is administrator rights, i.e. the release branch is created by an administrator.
If bug (program error) is found to need to be repaired in the process of issuing branch test, returning to the second functional branch F2 again, repairing the second functional branch F2, and after repairing, generating a second instruction again to merge codes on the second functional branch F2 into the issuing branch.
Then, if the code on the issuing branch passes the test, a third instruction is generated for code issuing, and the third instruction is an instruction representing the requirement for code issuing. The code on the issue branch is then merged into the main branch according to the third instruction to form a new stable version. Referring to the third node P3, the stable version on the main branch is V1.1.1 at this time.
In some alternative embodiments, if the rights information is a second type of rights and the operational requirement is a requirement for code release, the external instruction is identified as a third instruction. The second type of rights is administrator rights, that is, the administrator has the right to merge the code on the release branch into the main branch.
In some alternative embodiments, the main branch is also set to a read-only state after merging the issue branch into the main branch.
After the code on the issue branch merges into the main branch to form a new stable version V1.1.1, the code on the first functional branch F1 (if development for the first new feature has been completed) can merge into the issue branch. Accordingly, if the code on the issue branch passes the test, a third instruction is generated for code issue. The code on the issue branch is then merged into the main branch according to the third instruction to form a new stable version. Referring to the fourth node P4, the stable version on the main branch is V1.2.1 at this time.
According to the code branch construction method, the code branches are simplified, the switching and merging of the code branches are ordered, the probability of merging conflicts in the version management process is reduced, and the development efficiency is improved. And, through the management of code submission (merging) authority, the confusion of code merging is reduced. Further, examination of submitted codes is enhanced, and code quality is improved.
Example 2
Fig. 4 is a schematic structural diagram of an electronic device according to the present embodiment. The electronic device includes a memory, a processor, and a computer program stored on the memory and executable on the processor, which when executed implements the code branch construction method of embodiment 1. The electronic device 30 shown in fig. 4 is merely an example and should not be construed as limiting the functionality and scope of use of embodiments of the present invention.
As shown in fig. 4, the electronic device 30 may be embodied in the form of a general purpose computing device, which may be a server device, for example. Components of electronic device 30 may include, but are not limited to: the at least one processor 31, the at least one memory 32, a bus 33 connecting the different system components, including the memory 32 and the processor 31.
The bus 33 includes a data bus, an address bus, and a control bus.
The processor 31 executes various functional applications and data processing, such as the code branch construction method of embodiment 1 of the present invention, by running a computer program stored in the memory 32.
The electronic device 30 may also communicate with one or more external devices 34 (e.g., keyboard, pointing device, etc.). Such communication may be through an input/output (I/O) interface 35. Also, model-generating device 30 may also communicate with one or more networks, such as a Local Area Network (LAN), a Wide Area Network (WAN), and/or a public network, such as the internet, via network adapter 36. As shown, network adapter 36 communicates with the other modules of model-generating device 30 via bus 33. It should be appreciated that although not shown in the figures, other hardware and/or software modules may be used in connection with the model-generating device 30, including, but not limited to: microcode, device drivers, redundant processors, external disk drive arrays, RAID (disk array) systems, tape drives, data backup storage systems, and the like.
It should be noted that although several units/modules or sub-units/modules of an electronic device are mentioned in the above detailed description, such a division is merely exemplary and not mandatory. Indeed, the features and functionality of two or more units/modules described above may be embodied in one unit/module in accordance with embodiments of the present invention. Conversely, the features and functions of one unit/module described above may be further divided into ones that are embodied by a plurality of units/modules.
The foregoing embodiments of the electronic device may also achieve corresponding technical effects of an embodiment of a code branch construction method, which have been described in detail and are not described herein again.
Example 3
The present embodiment provides a computer-readable storage medium having stored thereon a computer program which, when executed by a processor, implements the steps of the code branch construction method of embodiment 1.
More specifically, among others, readable storage media may be employed including, but not limited to: portable disk, hard disk, random access memory, read only memory, erasable programmable read only memory, optical storage device, magnetic storage device, or any suitable combination of the foregoing.
In a possible embodiment, the invention may also be implemented in the form of a program product comprising program code for causing a terminal device to carry out the steps of implementing the code branch construction method of embodiment 1, when said program product is run on the terminal device.
Wherein the program code for carrying out the invention may be written in any combination of one or more programming languages, which program code may execute entirely on the user device, partly on the user device, as a stand-alone software package, partly on the user device and partly on the remote device or entirely on the remote device.
The foregoing embodiments of a computer readable storage medium may also achieve technical effects corresponding to the embodiments of a code branch construction method, which have been described in detail and are not repeated herein.
While specific embodiments of the invention have been described above, it will be appreciated by those skilled in the art that this is by way of example only, and the scope of the invention is defined by the appended claims. Various changes and modifications to these embodiments may be made by those skilled in the art without departing from the principles and spirit of the invention, but such changes and modifications fall within the scope of the invention.
Claims (10)
1. A code branch construction method, comprising the steps of:
the external instruction is fetched and the external instruction is fetched,
identifying an external instruction;
when the external instruction is a first instruction, copying a main branch to a functional branch for an external user to develop new characteristics based on the functional branch, wherein the first instruction is an instruction representing external requirements for developing the new characteristics;
when the external instruction is a second instruction, merging the functional branch into an issuing branch for the external user to test or issue based on the issuing branch, wherein the second instruction is an instruction representing the requirement of the test;
when the external instruction is a third instruction, merging the issuing branch to the main branch, wherein the third instruction is an instruction representing the requirement of code issuing;
returning to the step of fetching external instructions.
2. The code branch construction method of claim 1, further comprising:
when the external instruction is a fourth instruction, copying the main branch to a patch branch for the external user to repair the patch based on the patch branch, wherein the fourth instruction is an instruction representing the requirement of repairing the patch;
and when the external instruction is a fifth instruction, merging the patch branch into the main branch and merging the patch branch into the release branch, wherein the fifth instruction is an instruction representing the requirement of patch release.
3. The code branch construction method of claim 2, wherein after merging the issue branch into the main branch, a corresponding version number is also set for the main branch;
and/or after merging the patch branches into the main branch, setting a corresponding version number for the main branch.
4. The code branch construction method of claim 1, wherein the functional branches are named based on a hump naming rule.
5. The code branch construction method of claim 2, wherein the fetching external instructions comprises:
and acquiring the authority information and the operation requirement of the external user so as to identify the external instruction.
6. The code branch construction method according to claim 5, wherein the acquiring the authority information and the operation requirement of the external user to identify the external instruction comprises:
if the authority information is a first type of authority and the operation requirement is an external requirement for developing a new characteristic, identifying the external instruction as the first instruction;
if the permission information is of a second type of permission and the operation requirement is a requirement of a test, identifying the external instruction as the second instruction;
if the authority information is of a second type and the operation requirement is a requirement for code release, identifying the external instruction as the third instruction;
if the authority information is of a first type and the operation requirement is a requirement for patch repair, identifying the external instruction as the fourth instruction;
and if the authority information is the second type of authority and the operation requirement is the requirement for patch release, identifying the external instruction as the fifth instruction.
7. The code branch construction method of claim 6, wherein the first type of rights is development rights and the second type of rights is administrator rights.
8. The code branch construction method of claim 2, wherein the main branch is further set to a read-only state after merging the issue branch to the main branch;
and/or, after merging the patch branch into the main branch, setting the main branch to a read-only state.
9. An electronic device comprising a memory, a processor and a computer program stored on the memory and executable on the processor, characterized in that the processor implements the code branch construction method of any one of claims 1 to 8 when the computer program is executed by the processor.
10. A computer-readable storage medium, on which a computer program is stored, characterized in that the computer program, when executed by a processor, implements the code branch construction method of any one of claims 1 to 8.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202111653617.XA CN116414434A (en) | 2021-12-30 | 2021-12-30 | Code branch construction method, electronic device and storage medium |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202111653617.XA CN116414434A (en) | 2021-12-30 | 2021-12-30 | Code branch construction method, electronic device and storage medium |
Publications (1)
| Publication Number | Publication Date |
|---|---|
| CN116414434A true CN116414434A (en) | 2023-07-11 |
Family
ID=87048188
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202111653617.XA Pending CN116414434A (en) | 2021-12-30 | 2021-12-30 | Code branch construction method, electronic device and storage medium |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN116414434A (en) |
-
2021
- 2021-12-30 CN CN202111653617.XA patent/CN116414434A/en active Pending
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN110297689B (en) | Intelligent contract execution method, device, equipment and medium | |
| US10180836B1 (en) | Generating source code review comments using code analysis tools | |
| CN111198868B (en) | Intelligent database-dividing real-time data migration method and device | |
| US10481893B1 (en) | Identifying and resolving firmware component dependencies | |
| US10678626B2 (en) | Distributed product deployment validation | |
| CN111414391A (en) | Method and system for accessing multiple data sources | |
| US10572247B2 (en) | Prototype management system | |
| CN110941547A (en) | Automatic test case library management method, device, medium and electronic equipment | |
| US11200049B2 (en) | Automated test authorization management | |
| US10782940B2 (en) | Code library version management | |
| TW202034155A (en) | Negative zero control in instruction execution | |
| US10657230B2 (en) | Analysis of output files | |
| CN116569141A (en) | Workflow repair | |
| CN113448614A (en) | Software project code management method and device, storage medium and electronic equipment | |
| US8819494B2 (en) | Automatically changing parts in response to tests | |
| US11182272B2 (en) | Application state monitoring | |
| US20230281316A1 (en) | On-demand application vulnerability scanning | |
| CN116414434A (en) | Code branch construction method, electronic device and storage medium | |
| US11429513B1 (en) | Testing and verifying cloud services using a computational graph | |
| Souri | Formal specification and verification of a data replication approach in distributed systems | |
| CN113392002A (en) | Test system construction method, device, equipment and storage medium | |
| US20210089432A1 (en) | Prevent application outages through operations driven development | |
| US10248396B1 (en) | Code review with automated translation | |
| US11645142B1 (en) | Use sequential set index for root cause location and problem verification | |
| US11663181B2 (en) | Database replication using heterogenous encoding |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination | ||
| SE01 | Entry into force of request for substantive examination |