Consistent execution of partial queries in hybrid DBMS

Patent metadata

Field	Value
Publication number	US-10180946-B2
Application number	US-201715807895-A
Country	US
Kind code	B2
Filing date	Nov 9, 2017
Priority date	Aug 11, 2016
Publication date	Jan 15, 2019
Grant date	Jan 15, 2019

Abstract

The disclosure relates to a system comprising a first and a second database engine and a replication module. The replication module replicates changes from a first database maintained by the first engine to a second database maintained by the second engine. The system maps state times and sync times. The state times are specified in a first temporal reference system used by the first engine and the sync times are specified in a second temporal reference system used by the second engine. Each mapped state time and sync time pair indicate an identical state of the first and second database or parts thereof. The system executes a query partially by the first and partially by the second engine and uses the mapping to execute the query by the first and/or second engine on data of a single defined state.

First claim

What is claimed is:

1. A computer-implemented method for processing a query against a database table in a data processing system, the method comprising:
mapping a state time and a sync time, the state time specified in a first temporal reference system used by a first database engine for maintaining a first instance of a database table, the sync time being specified in a second temporal reference system used by a second database engine for maintaining a second instance of the database table, wherein the second instance of the database table at a particular sync time shares a state with the first instance of the database table at a particular state time corresponding to the particular sync time;
identifying a change made to the first instance of the database table, the change being introduced by a write transaction executed by the first database engine at a commit time, the change creating a new state of the first instance of the database table, the change stored in association with a state time indicating the commit time of the write transaction that introduced the change;
asynchronously replicating the change to the second instance of the database table, the replicated change being stored in association with a sync time indicating when the change was committed to the second instance of the database table and mapped to the state time indicating the commit time of the write transaction that introduced the change;
receiving a first query against the database table, the first query having at least a first part and a second part, and in response:
identifying a first query state time, the first query state time being the commit time of a write transaction having committed most recently before the receipt of the first query;
determining that the first part of the first query shall be performed by the first database engine and the second part of the first query shall be performed by the second database engine;
immediately executing at least the first part of the first query against the first instance of the database table using the query state time as a filter to exclude any changes in the first table instance having a state time that chronologically follows the identified query state time, the execution of at least the first part of the first query generating a first result;
identifying a query sync time, the query sync time being the time when all changes in the first table instance having committed before the query state time have been replicated;
delaying the execution of at least of the second part of the first query until the identified query sync time;
executing at least the second part of the query against the second instance of the database table using the query sync time as a filter to exclude any changes in the second table instance having assigned a sync time that chronologically follows the identified query sync time, the execution of at least the second part of the query generating a second result; and
returning a combination of the first and second result as a final result.

2. The computer-implemented method of claim 1 , further comprising receiving a second query against the database table, the second query having at least a first part and a second part, and in response:
identifying a second query state time, the second query state time being the commit time of a write transaction having committed most recently before the receipt of the second query;
determining that the second query shall be performed completely by the first database engine;
immediately executing the second query against the first instance of the database table using the second query state time as a filter to exclude any changes in the first table instance having a state time that chronologically follows the identified second query state time, the execution of the second query generating a third result; and
returning the third result as a final result.

3. The computer-implemented method of claim 2 , wherein determining that the second query shall be performed completely by the first database engine comprises automatically determining a current latency time for replicating changes from the first table instance to the second instance of the database table; and
determining that the current latency time exceeds a replication latency time threshold.

4. The computer-implemented method of claim 1 , further comprising receiving a third query against the database table, the third query having at least a first part and a second part, and in response:
identifying a third query state time, the third query state time being the commit time of a write transaction having committed most recently before the receipt of the third query;
determining that the third query shall be performed completely by the second database engine;
identifying a second query sync time, the second query sync time being the time when all changes in the first table instance having committed before the third query state time have been replicated;
delaying the execution of the third query until the identified query sync time;
executing the third query against the second instance of the database table using the third query sync time as a filter to exclude any changes in the second table instance having assigned a sync time that chronologically follows the identified second query sync time, the execution of the third query generating a fourth result; and
returning the fourth result as a final result.

5. The computer-implemented method of claim 1 , further comprising computing the final result by combining the first and second result via an SQL operation.

6. The computer-implemented method of claim 1 , wherein determining that the first part of the query shall be performed by the first database engine and the second part of the query shall be performed by the second database engine comprises automatically determining that the received query is configured to access at least a first and a second table, an instance of the first table being maintained by the first database engine but not by the second database engine, an instance of the second table being maintained by the second database engine but not by the first database engine and, in response to this determination, determining that the query shall be executed in part by the first database engine and in part by the second database engine.

7. The computer-implemented method of claim 1 , wherein determining that the first part of the query shall be performed by the first database engine and the second part of the query shall be performed by the second database engine comprises automatically evaluating the received query, the received query comprising one or more read statements of a first type and one or more read statements of a second type, the first database engine being speed-optimized for performing the first type of statement and the second database engine being speed-optimized for performing the second type of statement, and determining that the query shall be performed by performing the statements of the query of the first type by the first database engine and by performing the statements of the query of the second type by the second database engine.

8. The computer-implemented method of claim 1 , each state time being selected from a group comprising:
a time measured by a clock operatively coupled to the first database engine upon a commit event of a write transaction in a first database maintained by the first database engine;
a transaction-ID generated by the first database engine upon a commit event of the transaction;
an MVCC version number generated by a first MVCC module operatively coupled to the first database engine; and
a log-record-ID generated by the first database engine upon logging a commit event of the transaction in a first database

Assignees

• IBM

Inventors

• Brodt Andreas
• Martin Daniel
• Mueller Jens P
• Schiller Oliver
• Stolze Knut

Classifications

• G06F17/30522

  Physics · mapped topic

• G06F17/30477

  Physics · mapped topic

• G06F17/30174 Primary

  Physics · mapped topic

• G06F16/2455 Primary

  Query execution · CPC title

• G06F16/2457

  with adaptation to user needs · CPC title