CN111190912A - Large-transaction-oriented fragment execution method and device based on row change - Google Patents
Large-transaction-oriented fragment execution method and device based on row change Download PDFInfo
- Publication number
- CN111190912A CN111190912A CN201911378904.7A CN201911378904A CN111190912A CN 111190912 A CN111190912 A CN 111190912A CN 201911378904 A CN201911378904 A CN 201911378904A CN 111190912 A CN111190912 A CN 111190912A
- Authority
- CN
- China
- Prior art keywords
- row change
- transaction
- row
- change
- queue
- 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.)
- Granted
Links
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F16/00—Information retrieval; Database structures therefor; File system structures therefor
- G06F16/20—Information retrieval; Database structures therefor; File system structures therefor of structured data, e.g. relational data
- G06F16/23—Updating
- G06F16/2308—Concurrency control
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F16/00—Information retrieval; Database structures therefor; File system structures therefor
- G06F16/20—Information retrieval; Database structures therefor; File system structures therefor of structured data, e.g. relational data
- G06F16/24—Querying
- G06F16/245—Query processing
- G06F16/2455—Query execution
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/46—Multiprogramming arrangements
- G06F9/466—Transaction processing
-
- 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)
- Theoretical Computer Science (AREA)
- Data Mining & Analysis (AREA)
- Databases & Information Systems (AREA)
- Physics & Mathematics (AREA)
- General Engineering & Computer Science (AREA)
- General Physics & Mathematics (AREA)
- Computational Linguistics (AREA)
- Information Retrieval, Db Structures And Fs Structures Therefor (AREA)
Abstract
The utility model discloses a large-transaction oriented fragment execution method and a device based on row change, which comprises the following steps: acquiring row change data of a synchronized database, converting the row change data into a row change object and pushing the row change object to a row change queue; extracting row change objects from the row change queue, converting a plurality of row change objects into a transaction object and pushing the transaction object to the transaction queue; and (3) fragmenting the large transaction object, acquiring the fragmented transaction object from the transaction queue, analyzing the fragmented transaction object into corresponding sql statements, and fragmenting and executing the sql statements in a second database, wherein the second database synchronously updates row change data. The method comprises the steps of fragmenting a large transaction object by combining a plurality of line change objects into the large transaction object, and analyzing the large transaction object into sql statement fragments for execution; and line change pushing, transaction pushing and transaction execution parallel processing are performed, so that the real-time performance of line change data synchronization is ensured, and the synchronization efficiency is improved.
Description
Technical Field
The present disclosure relates to the field of computer technologies, and in particular, to a large-transaction-oriented fragment execution method and apparatus based on row change.
Background
The statements in this section merely provide background information related to the present disclosure and may not necessarily constitute prior art.
The row change is data row change caused by database transaction execution, and a row change comprises a row belonging user, a row belonging table, a change type (deletion, new addition or update), row data before and after the change and the like. The data synchronization between the two databases is realized by reading all row changes of the synchronized databases and then converting the row changes into corresponding sql statements to be executed on the other database; and simultaneously, in order to ensure the integrity of the transaction, all row changes of one transaction are selected to be read at one time, then all sql statements obtained based on row change conversion are executed in one transaction, and finally, the sql statements are submitted at one time.
However, when a large transaction is encountered, the large transaction is a transaction that causes a large number of row changes, for example, one transaction changes tens of millions or billions of data, and at this time, if all row changes are read in at one time, the operating environment needs to have a very high memory configuration.
How to implement synchronization of large transactions based on row change without modifying the memory configuration of the operating environment, and meanwhile, ensuring the integrity of the transactions is a problem to be solved at present.
Disclosure of Invention
In order to solve the above problems, the present disclosure provides a large transaction-oriented fragment execution method and device based on row change, in which a large transaction object is fragmented and parsed into sql statement fragments for execution; and line change pushing, transaction pushing and transaction execution parallel processing are performed, so that the real-time performance of line change data synchronization is ensured, and the synchronization efficiency is improved.
In order to achieve the purpose, the following technical scheme is adopted in the disclosure:
in a first aspect, the present disclosure provides a large-transaction-oriented sharding execution method based on row change, including:
acquiring row change data of a synchronized database, converting the row change data into a row change object and pushing the row change object to a row change queue;
extracting row change objects from the row change queue, converting a plurality of row change objects into a transaction object and pushing the transaction object to the transaction queue;
and (3) fragmenting the large transaction object, acquiring the fragmented transaction object from the transaction queue, analyzing the fragmented transaction object into corresponding sql statements, and fragmenting and executing the sql statements in a second database, wherein the second database synchronously updates row change data.
As some possible implementations, the converting the multiple line change objects into a transaction object and pushing the transaction object to the transaction queue includes:
initializing a row change list, extracting a row change object from a row change queue, and storing the row change object in the row change list;
acquiring a head row change object from a row change queue, deleting the row change object from the row change queue, and judging whether the row change object is empty or not;
if the row change object is empty, forming all the row change objects in the row change list into a transaction object, pushing the transaction object into the transaction list, setting the memory size occupied by the transaction object as the sum of the memory sizes of all the row change objects, and emptying the row change list;
if the row change data is not empty, the row change data is added to a row change list, the operation is returned to continue to delete the head row change object from the row change queue, and whether the row change object is empty or not is judged.
As some possible implementations, the synchronously updating the row change data by the second database includes:
dividing a large transaction object into a plurality of fragment transaction objects, deleting a head fragment transaction object from a transaction queue, and judging whether the fragment transaction object is empty or not;
if the signal is empty, ending; if not, converting all row changes in the fragment transaction object into sql statements and executing the sql statements in a second database;
after the execution is successful, judging whether the fragment transaction object is the last fragment of the large transaction object, if so, submitting the current transaction; otherwise, returning to the continuous operation to delete the head fragment transaction object from the transaction queue, and judging whether the fragment transaction object is empty.
In a second aspect, the present disclosure provides a large-transaction-oriented sharded execution device based on row change, including:
the row change pushing module is used for acquiring row change data of the synchronized database, converting the row change data into a row change object and pushing the row change object to a row change queue;
the transaction pushing module is used for extracting the row change objects from the row change queue, converting a plurality of row change objects into a transaction object and pushing the transaction object to the transaction queue;
and the transaction execution module is used for fragmenting the large transaction object, acquiring the fragmented transaction object from the transaction queue, analyzing the fragmented transaction object into corresponding sql statements, and executing the sql statements in a second database in a fragmentation mode, wherein the second database synchronously updates row change data.
In a third aspect, the present disclosure provides an electronic device, including a memory, a processor, and a computer program stored in the memory and executable on the processor, where the processor implements the steps of the method for executing a large-transaction oriented fragment based on line change when executing the program.
In a fourth aspect, the present disclosure provides a computer readable storage medium having stored thereon a computer program, which when executed by a processor, performs the steps of a method for large transaction oriented sharded execution based on row changes.
Compared with the prior art, the beneficial effect of this disclosure is:
by fragmenting the large transaction object, analyzing the fragmented transaction object into sql statements and executing the sql statements in a fragmentation manner, the memory configuration requirement on the operating environment is reduced, and the resource waste of high memory is avoided;
the large transaction object is processed in a fragmentation mode, namely the synchronization speed of row change data is ensured, and meanwhile the integrity of the transaction object is also ensured;
the line change pushing, the transaction pushing and the transaction executing are processed in parallel, the real-time performance of line change data synchronization is also guaranteed, and the synchronization efficiency is improved.
Drawings
The accompanying drawings, which are included to provide a further understanding of the disclosure, illustrate embodiments of the disclosure and together with the description serve to explain the disclosure and are not to limit the disclosure.
FIG. 1 is a flow diagram of a large transaction oriented sharding execution method based on row changes;
FIG. 2 is a schematic diagram of a large transaction oriented sharded execution device based on row change;
FIG. 3 is a flow chart of an execution of a row change push module;
FIG. 4 is a flowchart illustrating the execution of the transaction push module;
FIG. 5 is a flow chart of the execution of the transaction execution module.
The specific implementation mode is as follows:
the present disclosure is further described with reference to the following drawings and examples.
It should be noted that the following detailed description is exemplary and is intended to provide further explanation of the disclosure. Unless defined otherwise, all technical and scientific terms used herein have the same meaning as commonly understood by one of ordinary skill in the art to which this disclosure belongs.
It is noted that the terminology used herein is for the purpose of describing particular embodiments only and is not intended to be limiting of example embodiments according to the present disclosure. As used herein, the singular forms "a", "an" and "the" are intended to include the plural forms as well, and it should be understood that when the terms "comprises" and/or "comprising" are used in this specification, they specify the presence of stated features, steps, operations, devices, components, and/or combinations thereof, unless the context clearly indicates otherwise.
Example 1
The present disclosure provides a large transaction oriented fragment execution method based on row change, and the embodiment includes the following steps:
s1: acquiring row change data of a synchronized database, converting the row change data into a row change object and pushing the row change object to a row change queue;
s2: extracting row change objects from the row change queue, converting a plurality of row change objects into a transaction object and pushing the transaction object to the transaction queue;
s3: and (4) fragmenting the large transaction object, acquiring the fragmented transaction object from the transaction queue, analyzing the fragmented transaction object into corresponding sql statements, executing the sql statements in a second database, and synchronously updating row change data by the second database.
As shown in fig. 2-5, the noun meanings in the figures are explained as follows:
CURRENT _ MEM _ SIZE: the total amount of memory occupied by all unexecuted line change in the operating environment;
MAX _ MEM _ SIZE: the maximum memory occupation amount of all the unexecuted row changes allowed to be stored in the running environment can be dynamically set according to the specific running environment;
row: line change objects including users to which line changes belong, tables to which line changes belong, change types (insert, update, delete), and line data before and after the change;
transformation: a transaction object, including multiple row change object data, exists in the sense that multiple row changes are performed in batches at a time.
Step S1 includes:
s101: reading row change data into an operating environment, and setting the total occupied amount of unexecuted row change memory;
after reading the row change data, the value becomes the sum of the original memory size and the memory size of the read row change data;
s102: converting the row change data into a row change object and pushing the row change object to a row change queue;
s103: comparing the total memory occupation amount of the unexecuted row change with the preset maximum memory occupation amount which allows the storage of the unexecuted row change, if the former is larger than the latter, continuing to execute the step S103 until the latter is larger than the former, and returning to the step S101;
that is, as long as the memory occupancy does not satisfy the determination condition, the row change data is not read from the operating environment memory.
S104: otherwise, return to step S101. That is, the row change data is continuously read, all the row change data may not be completely read by performing reading once, the row change data is re-read, and the total occupied amount of the unexecuted row change memory is reset.
Step S2 includes:
s201: initializing a row change list, extracting a row change object from a row change queue, and storing the row change object in the row change list;
s202: acquiring a head row change object from a row change queue, deleting the row change object from the row change queue, and judging whether the row change object is empty or not;
s203: if yes, comparing the total memory occupation amount of the unexecuted row change with the preset maximum memory occupation amount of the unexecuted row change allowed to be stored,
s203-1: if the former is larger than the latter, all the row change objects in the row change list form a transaction object and are pushed into the transaction list, the memory size occupied by the transaction object is set to be the sum of the memory sizes of all the row change objects, and the row change list is emptied;
s203-2: otherwise, returning to step S202;
s204: if the row change data is not empty, determining whether the row change data is the last row change object of the large transaction,
s204-1: if so, forming all row change objects in the row change list into a transaction object, pushing the transaction object into the transaction list, setting the memory size occupied by the transaction object as the sum of the memory sizes of all the row change objects, and emptying the row change list;
s204-2: otherwise, it is added to the line change list, and the process returns to step S202.
Step S3 includes:
s301: dividing a large transaction object into a plurality of fragment transaction objects, deleting a head fragment transaction object from a transaction queue, and judging whether the fragment transaction object is empty or not;
s302: if the signal is empty, ending; if not, converting all row changes in the fragment transaction object into sql statements and executing the sql statements in a second database;
s303: judging whether the execution is successful, if the execution is unsuccessful, converting the execution into an sql statement again; if the execution is successful, forcibly recovering the memory occupied by the transaction object, and setting the total occupied amount of the unexecuted line change memory as the difference between the original total occupied amount of the unexecuted line change memory and the size of the memory occupied by the fragmented transaction object;
s304: after the execution is successful, judging whether the fragment transaction object is the last fragment of the transaction object, if so, submitting the current transaction; otherwise, return to step S301.
Example 2
The utility model provides a large-transaction oriented slicing execution device based on row change, which comprises a row change pushing module, a transaction pushing module and a transaction execution module;
the line change pushing module, the transaction pushing module and the transaction executing module are executed in parallel.
The Row change pushing module is responsible for converting Row change into Row (Row change object) and pushing the Row change to RowQueue (Row change queue);
RowQueue is responsible for storing the pushed line changes;
the Transaction pushing module is responsible for acquiring Row from RowQueue, converting Row into Transaction (Transaction object) and pushing the Transaction object to TransQueue (Transaction queue);
TransQueue is responsible for storing transactions to be executed;
and the Transaction execution module is responsible for acquiring transactions from TransQueue and resolving the transactions into corresponding sql statements for execution.
Example 3
The present disclosure provides an electronic device, including a memory, a processor, and a computer program stored in the memory and executable on the processor, where the processor implements the steps of a large-transaction oriented fragment execution method based on line change when executing the program.
Example 4
The present disclosure provides a computer readable storage medium having stored thereon a computer program, wherein the program, when executed by a processor, implements the steps of a large transaction oriented sharded execution method based on line changes.
As will be appreciated by one skilled in the art, embodiments of the present disclosure may be provided as a method, system, or computer program product. Accordingly, the present disclosure may take the form of an entirely hardware embodiment, an entirely software embodiment or an embodiment combining software and hardware aspects. Furthermore, the present disclosure may take the form of a computer program product embodied on one or more computer-usable storage media (including, but not limited to, disk storage, CD-ROM, optical storage, and so forth) having computer-usable program code embodied therein.
The present disclosure is described with reference to flowchart illustrations and/or block diagrams of methods, apparatus (systems), and computer program products according to embodiments of the disclosure. It will be understood that each flow and/or block of the flow diagrams and/or block diagrams, and combinations of flows and/or blocks in the flow diagrams and/or block diagrams, can be implemented by computer program instructions. These computer program instructions may be provided to a processor of a general purpose computer, special purpose computer, embedded processor, or other programmable data processing apparatus to produce a machine, such that the instructions, which execute via the processor of the computer or other programmable data processing apparatus, create means for implementing the functions specified in the flowchart flow or flows and/or block diagram block or blocks.
These computer program instructions may also be stored in a computer-readable memory that can direct a computer or other programmable data processing apparatus to function in a particular manner, such that the instructions stored in the computer-readable memory produce an article of manufacture including instruction means which implement the function specified in the flowchart flow or flows and/or block diagram block or blocks.
These computer program instructions may also be loaded onto a computer or other programmable data processing apparatus to cause a series of operational steps to be performed on the computer or other programmable apparatus to produce a computer implemented process such that the instructions which execute on the computer or other programmable apparatus provide steps for implementing the functions specified in the flowchart flow or flows and/or block diagram block or blocks.
The above is merely a preferred embodiment of the present disclosure and is not intended to limit the present disclosure, which may be variously modified and varied by those skilled in the art. Any modification, equivalent replacement, improvement and the like made within the spirit and principle of the present disclosure should be included in the protection scope of the present disclosure.
Although the present disclosure has been described with reference to specific embodiments, it should be understood that the scope of the present disclosure is not limited thereto, and those skilled in the art will appreciate that various modifications and changes can be made without departing from the spirit and scope of the present disclosure.
Claims (10)
1. A large-transaction oriented sharded execution method based on line change is characterized by comprising the following steps:
acquiring row change data of a synchronized database, converting the row change data into a row change object and pushing the row change object to a row change queue;
extracting row change objects from the row change queue, converting a plurality of row change objects into a transaction object and pushing the transaction object to the transaction queue;
and (3) fragmenting the large transaction object, acquiring the fragmented transaction object from the transaction queue, analyzing the fragmented transaction object into corresponding sql statements, and fragmenting and executing the sql statements in a second database, wherein the second database synchronously updates row change data.
2. The large transaction-oriented sharded execution method based on line changes as recited in claim 1,
the pushing to the row change queue comprises:
reading row change data, and setting the total occupied amount of the unexecuted row change memory;
converting the row change data into a row change object and pushing the row change object to a row change queue;
comparing the total memory occupation amount of the unexecuted row change with the preset maximum memory occupation amount of the unexecuted row change allowed to be stored, and if the former is larger than the latter, ending the operation; otherwise, resetting the total occupied amount of the unexecuted row change memory.
3. The large transaction-oriented sharded execution method based on line changes as recited in claim 1,
the step of converting the plurality of row change objects into a transaction object and pushing the transaction object to the transaction queue comprises the following steps:
initializing a row change list, extracting a row change object from a row change queue, and storing the row change object in the row change list;
acquiring a head row change object from a row change queue, deleting the row change object from the row change queue, and judging whether the row change object is empty or not;
if the row change object is empty, forming all the row change objects in the row change list into a transaction object, pushing the transaction object into the transaction list, setting the memory size occupied by the transaction object as the sum of the memory sizes of all the row change objects, and emptying the row change list;
if the row change data is not empty, the row change data is added to a row change list, the operation is returned to continue to delete the head row change object from the row change queue, and whether the row change object is empty or not is judged.
4. The large transaction-oriented sharded execution method based on line changes as recited in claim 3,
if the row change object is empty, before forming a transaction object, the method includes:
comparing the total occupied amount of the unexecuted row change memory with the preset maximum value of the memory occupied amount of the unexecuted row change allowed to be stored, if the former is larger than the latter, forming all row change objects in a row change list into a transaction object, pushing the transaction object into the transaction list, setting the memory occupied size of the transaction object as the sum of the memory sizes of all the row change objects, and emptying the row change list;
otherwise, returning to the continuous operation to delete the head row change object from the row change queue, and judging whether the row change object is empty.
5. The large transaction-oriented sharded execution method based on line changes as recited in claim 3,
if the column change data is not empty, adding the column change data to the column change list comprises:
judging whether the row change data is the last row change object of a large transaction, if so, forming all the row change objects in a row change list into a transaction object, pushing the transaction object into the transaction list, setting the memory size occupied by the transaction object as the sum of the memory sizes of all the row change objects, and emptying the row change list;
otherwise, adding the row change list into the row change list, returning to the continuous operation to delete the head row change object from the row change queue, and judging whether the row change object is empty or not.
6. The large transaction-oriented sharded execution method based on line changes as recited in claim 1,
the second database synchronously updating the row change data comprises:
dividing the transaction object in the transaction queue into a plurality of fragment transaction objects, deleting the head fragment transaction object from the transaction queue, and judging whether the fragment transaction object is empty or not;
if the signal is empty, ending; if not, converting all row changes in the fragment transaction object into sql statements and executing the sql statements in a second database;
after the execution is successful, judging whether the fragment transaction object is the last fragment of the transaction object, if so, submitting the current transaction; otherwise, returning to the continuous operation to delete the head fragment transaction object from the transaction queue, and judging whether the fragment transaction object is empty.
7. The large transaction-oriented sharded execution method based on line changes as recited in claim 6,
the step of converting all row changes in the fragment transaction object into sql statements and executing the sql statements in the second database further comprises the step of;
judging whether the execution is successful, if the execution is unsuccessful, converting the execution into an sql statement again; if the execution is successful, the transaction object is forcibly recycled to occupy the memory, and the total occupied amount of the unexecuted line change memory is set to be the difference between the original total occupied amount of the unexecuted line change memory and the size of the memory occupied by the fragment transaction object.
8. A large transaction oriented sharded execution apparatus based on row change, comprising:
the row change pushing module is used for acquiring row change data of the synchronized database, converting the row change data into a row change object and pushing the row change object to a row change queue;
the transaction pushing module is used for extracting the row change objects from the row change queue, converting a plurality of row change objects into a transaction object and pushing the transaction object to the transaction queue;
and the transaction execution module is used for fragmenting the large transaction object, acquiring the fragmented transaction object from the transaction queue, analyzing the fragmented transaction object into corresponding sql statements, and executing the sql statements in a second database in a fragmentation mode, wherein the second database synchronously updates row change data.
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 method according to any of claims 1-7 when executing the program.
10. A computer-readable storage medium, on which a computer program is stored which, when being executed by a processor, carries out the method according to any one of claims 1 to 7.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201911378904.7A CN111190912B (en) | 2019-12-27 | 2019-12-27 | Large-transaction-oriented sharding execution method and device based on line change |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201911378904.7A CN111190912B (en) | 2019-12-27 | 2019-12-27 | Large-transaction-oriented sharding execution method and device based on line change |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN111190912A true CN111190912A (en) | 2020-05-22 |
| CN111190912B CN111190912B (en) | 2023-06-20 |
Family
ID=70706001
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN201911378904.7A Active CN111190912B (en) | 2019-12-27 | 2019-12-27 | Large-transaction-oriented sharding execution method and device based on line change |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN111190912B (en) |
Cited By (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN114035982A (en) * | 2021-11-08 | 2022-02-11 | 中电福富信息科技有限公司 | APM index slice calculation method and system based on event driving |
Citations (10)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN1524226A (en) * | 2001-03-07 | 2004-08-25 | 甲骨文国际公司 | Managing checkpoint queues in a multiple node system |
| CN102047252A (en) * | 2008-05-26 | 2011-05-04 | 微软公司 | Paging hierarchical data |
| CN103677771A (en) * | 2012-09-06 | 2014-03-26 | 阿里巴巴集团控股有限公司 | Processing method and device for concurrent transactions |
| US20140372486A1 (en) * | 2013-06-12 | 2014-12-18 | Oracle International Corporation | In-Database Sharded Queue |
| US20160171002A1 (en) * | 2014-12-12 | 2016-06-16 | International Business Machines Corporation | Merging database operations for serializable transaction execution |
| CN105740344A (en) * | 2016-01-25 | 2016-07-06 | 中国科学院计算技术研究所 | Sql statement combination method and system independent of database |
| CN107679237A (en) * | 2017-10-26 | 2018-02-09 | 杨晓艳 | A kind of distributed data base management system (DDBMS), method and device |
| CN108701051A (en) * | 2016-05-25 | 2018-10-23 | 谷歌有限责任公司 | The consistent Notification of Changes of Real-time Transaction |
| CN109885617A (en) * | 2019-01-29 | 2019-06-14 | 中国工商银行股份有限公司 | The method of data synchronization and device of Distributed Heterogeneous Database system |
| CN110249321A (en) * | 2017-09-29 | 2019-09-17 | 甲骨文国际公司 | For the system and method that capture change data use from distributed data source for heterogeneous target |
-
2019
- 2019-12-27 CN CN201911378904.7A patent/CN111190912B/en active Active
Patent Citations (10)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN1524226A (en) * | 2001-03-07 | 2004-08-25 | 甲骨文国际公司 | Managing checkpoint queues in a multiple node system |
| CN102047252A (en) * | 2008-05-26 | 2011-05-04 | 微软公司 | Paging hierarchical data |
| CN103677771A (en) * | 2012-09-06 | 2014-03-26 | 阿里巴巴集团控股有限公司 | Processing method and device for concurrent transactions |
| US20140372486A1 (en) * | 2013-06-12 | 2014-12-18 | Oracle International Corporation | In-Database Sharded Queue |
| US20160171002A1 (en) * | 2014-12-12 | 2016-06-16 | International Business Machines Corporation | Merging database operations for serializable transaction execution |
| CN105740344A (en) * | 2016-01-25 | 2016-07-06 | 中国科学院计算技术研究所 | Sql statement combination method and system independent of database |
| CN108701051A (en) * | 2016-05-25 | 2018-10-23 | 谷歌有限责任公司 | The consistent Notification of Changes of Real-time Transaction |
| CN110249321A (en) * | 2017-09-29 | 2019-09-17 | 甲骨文国际公司 | For the system and method that capture change data use from distributed data source for heterogeneous target |
| CN107679237A (en) * | 2017-10-26 | 2018-02-09 | 杨晓艳 | A kind of distributed data base management system (DDBMS), method and device |
| CN109885617A (en) * | 2019-01-29 | 2019-06-14 | 中国工商银行股份有限公司 | The method of data synchronization and device of Distributed Heterogeneous Database system |
Cited By (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN114035982A (en) * | 2021-11-08 | 2022-02-11 | 中电福富信息科技有限公司 | APM index slice calculation method and system based on event driving |
Also Published As
| Publication number | Publication date |
|---|---|
| CN111190912B (en) | 2023-06-20 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN107038206B (en) | LSM tree establishing method, LSM tree data reading method and server | |
| US8719237B2 (en) | Method and apparatus for deleting duplicate data | |
| US20150331619A1 (en) | Data storage method and apparatus | |
| CN102129425B (en) | The access method of big object set table and device in data warehouse | |
| US10120860B2 (en) | Methods and apparatus to identify a count of n-grams appearing in a corpus | |
| CN111914020A (en) | Data synchronization method and device and data query method and device | |
| CN110647423B (en) | Method, device and readable medium for creating storage volume mirror image based on application | |
| CN103593447A (en) | Data processing method and device applied to database table | |
| CN111190912A (en) | Large-transaction-oriented fragment execution method and device based on row change | |
| CN104063374A (en) | Data deduplication method and equipment | |
| CN103778219A (en) | HBase-based method for updating incremental indexes | |
| CN108205559B (en) | Data management method and equipment thereof | |
| US9858170B2 (en) | Function-calling-information collection method and computer-readable recording medium | |
| CN110928665A (en) | Data processing method, device, storage medium and terminal | |
| CN110196786B (en) | Method and equipment for controlling memory in database rollback synchronization | |
| US11775515B2 (en) | Dataset optimization framework | |
| CN112711627B (en) | Data importing method, device and equipment of Greemplum database | |
| CN107291574B (en) | Backup data recovery primary key generation method based on interpretation system | |
| CN110413617B (en) | Method for dynamically adjusting hash table group according to size of data volume | |
| CN109284237B (en) | Garbage recovery method and system in full flash memory array | |
| CN113220719A (en) | Mass dimension data association query optimization method and system | |
| JP6557720B2 (en) | Database system, apparatus, method and program | |
| CN110688325B (en) | Garbage recycling method, device and equipment for solid state disk and storage medium | |
| CN116561120B (en) | Data file rapid merging method and system for time sequence database | |
| JP7481244B2 (en) | Data synchronization system, data synchronization device and data synchronization method |
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 | ||
| GR01 | Patent grant | ||
| GR01 | Patent grant |