US6631374B1
Expired / Lapsed
US
⏱️ 0.0 years remaining
System and method for providing fine-grained temporal database access
Assignee: Oracle International Corp
•
Filing: 2000-09-29
•
Granted: 2003-10-07
•
Expires: 2020-09-29
Abstract
Abstract A system and method for selectively viewing temporal row data in a consistent read-implemented database are described. Committed transactions effecting row data changes to a database are tracked and a stored system change number is assigned upon each committed transaction. Rollback segments for uncommitted transactions are stored. Each rollback segment stores a transaction identifier and transaction table entries containing ordered row data values reflecting the database changes. The database is transitioned into successive consistent versions responsive to each committed transaction at a journaled commit time. The transaction table entries are maintained for a user-definable retention period following the commit time of each committed transaction. A queried selection of row data values from the database is performed as of a query time occurring prior to the commit time of at least one committed transaction. The ordered row data values contained in the rollback segments storing a transaction identifier for the at least one committed transaction are retrieved.
Inventors
- 👤 Jonathan D. Klein
- 👤 Amit Ganesh
- 👤 Juan R. Loaiza
- 👤 Gary C. Ngai
Bibliographic Details
Application Number
—
Jurisdiction
US
Data Source
google_patents
Last Synchronized
2026-11-03 16:08
CPC Classifications
G; G06; G06F; G06F16/00; G06F16/20; G06F16/24; G06F16/245; G06F16/2458; G06F16/2477; Y; Y10; Y10S; Y10S707/00; Y10S707/99931; Y10S707/99938; Y10S707/99951; Y10S707/99952; Y10S707/99953
Claims Analysis
Total Claims: 60
Claim 1
Independent Claim
128 words
A system for providing fine-grained temporal database access in a consistent read environment, comprising: a database engine tracking transactions committed to the database as successive consistent versions, each committed transaction generating a further consistent version of the database at a journaled commit time; a rollback mechanism storing transaction table entries for each uncommitted transaction, each transaction table entry storing retained data values reflecting database changes; a consistent read mechanism maintaining the transaction table entries for a user-definable retention period following the commit time of each transaction and presenting a logical view of the database as of a query time occurring prior to the commit time of at least one transaction by accessing the retained data values stored in the transaction table entries for the at least one transaction.
Claim 2
Independent Claim
128 words
A system for providing fine-grained temporal database access in a consistent read environment, comprising: a database engine tracking transactions committed to the database as successive consistent versions, each committed transaction generating a further consistent version of the database at a journaled commit time; a rollback mechanism storing transaction table entries for each uncommitted transaction, each transaction table entry storing retained data values reflecting database changes; a consistent read mechanism maintaining the transaction table entries for a user-definable retention period following the commit time of each transaction and presenting a logical view of the database as of a query time occurring prior to the commit time of at least one transaction by accessing the retained data values stored in the transaction table entries for the at least one transaction.
Claim 3
Dependent Claim
53 words
A system according to claim 1 , wherein each transaction table entry further comprises a transaction identifier, further comprising: the consistent read mechanism selectively retrieving the retained data values from the transaction table entries for only those such at least one transaction corresponding to a transaction identifier substantially contemporaneous to the query time.
Claim 4
Independent Claim
151 words
A system for providing fine-grained temporal database access in a consistent read environment, comprising: a database engine tracking transactions committed to the database as successive consistent versions, each committed transaction generating a further consistent version of the database at a journaled commit time; a rollback mechanism storing transaction table entries for each uncommitted transaction, each transaction table entry storing retained data values reflecting database changes; a consistent read mechanism maintaining the transaction table entries for a retention period following the commit time of each transaction and presenting a logical view of the database as of a query time occurring prior to the commit time of at least one transaction by accessing the retained data values stored in the transaction table entries for the at least one transaction; the rollback mechanism storing the retained data values into transaction table entries for each individual row within the database effected by an uncommitted transaction.
Claim 5
Independent Claim
151 words
A system for providing fine-grained temporal database access in a consistent read environment, comprising: a database engine tracking transactions committed to the database as successive consistent versions, each committed transaction generating a further consistent version of the database at a journaled commit time; a rollback mechanism storing transaction table entries for each uncommitted transaction, each transaction table entry storing retained data values reflecting database changes; a consistent read mechanism maintaining the transaction table entries for a retention period following the commit time of each transaction and presenting a logical view of the database as of a query time occurring prior to the commit time of at least one transaction by accessing the retained data values stored in the transaction table entries for the at least one transaction; the rollback mechanism storing the retained data values into transaction table entries for each individual row within the database effected by an uncommitted transaction.
Claim 6
Dependent Claim
45 words
A system according to claim 3 , further comprising: the consistent read mechanism generating a logical view of an individual row within the database by accessing the retained data values stored in the transaction table entries for each such transaction having effected that individual row.
Claim 7
Independent Claim
177 words
A system for providing fine-grained temporal database access in a consistent read environment, comprising: a database engine tracking transactions committed to the database as successive consistent versions, each committed transaction generating a further consistent version of the database at a journaled commit time; a rollback mechanism storing transaction table entries for each uncommitted transaction, each transaction table entry storing retained data values reflecting database changes; a consistent read mechanism maintaining the transaction table entries for a retention period following the commit time of each transaction and presenting a logical view of the database as of a query time occurring prior to the commit time of at least one transaction by accessing the retained data values stored in the transaction table entries for the at least one transaction; the rollback mechanism organizing the transaction table entries as a linked data structure comprising undo entries each storing at least part of the retained data values; and the consistent read mechanism traversing the linked data structure and selectively retrieving the retained data values stored substantially contemporaneous to the query time.
Claim 8
Independent Claim
177 words
A system for providing fine-grained temporal database access in a consistent read environment, comprising: a database engine tracking transactions committed to the database as successive consistent versions, each committed transaction generating a further consistent version of the database at a journaled commit time; a rollback mechanism storing transaction table entries for each uncommitted transaction, each transaction table entry storing retained data values reflecting database changes; a consistent read mechanism maintaining the transaction table entries for a retention period following the commit time of each transaction and presenting a logical view of the database as of a query time occurring prior to the commit time of at least one transaction by accessing the retained data values stored in the transaction table entries for the at least one transaction; the rollback mechanism organizing the transaction table entries as a linked data structure comprising undo entries each storing at least part of the retained data values; and the consistent read mechanism traversing the linked data structure and selectively retrieving the retained data values stored substantially contemporaneous to the query time.
Claim 9
Dependent Claim
41 words
A system according to claim 1 , further comprising: the consistent read mechanism determining the query time based on at least one of a standardized time reference, a relative time reference, and a system change number generated by each committed transaction.
Claim 10
Dependent Claim
31 words
A system according to claim 1 , wherein the data values reflect database changes to an object comprising at least one of an object, cell, row, record, table, window, and schema.
Claim 11
Dependent Claim
22 words
A system according to claim 1 , wherein the transaction comprises at least one of a select, join, and union database operation.
Claim 12
Independent Claim
122 words
A method for providing fine-grained temporal database access in a consistent read environment, comprising: transitioning a database into successive consistent versions by tracking transactions committed to the database, each committed transaction generating a further consistent version of the database at a journaled commit time; storing transaction table entries for each uncommitted transaction, each transaction table entry storing retained data values reflecting database changes; maintaining the transaction table entries for a user-definable retention period following the commit time of each transaction; and presenting a logical view of the database as of a query time occurring prior to the commit time of at least one transaction by accessing the retained data values stored in the transaction table entries for the at least one transaction.
Claim 13
Independent Claim
122 words
A method for providing fine-grained temporal database access in a consistent read environment, comprising: transitioning a database into successive consistent versions by tracking transactions committed to the database, each committed transaction generating a further consistent version of the database at a journaled commit time; storing transaction table entries for each uncommitted transaction, each transaction table entry storing retained data values reflecting database changes; maintaining the transaction table entries for a user-definable retention period following the commit time of each transaction; and presenting a logical view of the database as of a query time occurring prior to the commit time of at least one transaction by accessing the retained data values stored in the transaction table entries for the at least one transaction.
Claim 14
Dependent Claim
49 words
A method according to claim 9 , wherein each transaction table entry further comprises a transaction identifier, further comprising: selectively retrieving the retained data values from the transaction table entries for only those such at least one transaction corresponding to a transaction identifier substantially contemporaneous to the query time.
Claim 15
Independent Claim
142 words
A method for providing fine-grained temporal database access in a consistent read environment, comprising: transitioning a database into successive consistent versions by tracking transactions committed to the database, each committed transaction generating a further consistent version of the database at a journaled commit time; storing transaction table entries for each uncommitted transaction, each transaction table entry storing retained data values reflecting database changes; maintaining the transaction table entries for a retention period following the commit time of each transaction; presenting a logical view of the database as of a query time occurring prior to the commit time of at least one transaction by accessing the retained data values stored in the transaction table entries for the at least one transaction; and storing the retained data values into transaction table entries for each individual row within the database effected by an uncommitted transaction.
Claim 16
Independent Claim
142 words
A method for providing fine-grained temporal database access in a consistent read environment, comprising: transitioning a database into successive consistent versions by tracking transactions committed to the database, each committed transaction generating a further consistent version of the database at a journaled commit time; storing transaction table entries for each uncommitted transaction, each transaction table entry storing retained data values reflecting database changes; maintaining the transaction table entries for a retention period following the commit time of each transaction; presenting a logical view of the database as of a query time occurring prior to the commit time of at least one transaction by accessing the retained data values stored in the transaction table entries for the at least one transaction; and storing the retained data values into transaction table entries for each individual row within the database effected by an uncommitted transaction.
Claim 17
Dependent Claim
41 words
A method according to claim 11 , further comprising: generating a logical view of an individual row within the database by accessing the retained data values stored in the transaction table entries for each such transaction having effected that individual row.
Claim 18
Independent Claim
163 words
A method for providing fine-grained temporal database access in a consistent read environment, comprising: transitioning a database into successive consistent versions by tracking transactions committed to the database, each committed transaction generating a further consistent version of the database at a journaled commit time; storing transaction table entries for each uncommitted transaction, each transaction table entry storing retained data values reflecting database changes; maintaining the transaction table entries for a retention period following the commit time of each transaction; presenting a logical view of the database as of a query time occurring prior to the commit time of at least one transaction by accessing the retained data values stored in the transaction table entries for the at least one transaction; organizing the transaction table entries as a linked data structure comprising undo entries each storing at least part of the retained data values; and traversing the linked data structure and selectively retrieving the retained data values stored substantially contemporaneous to the query time.
Claim 19
Independent Claim
163 words
A method for providing fine-grained temporal database access in a consistent read environment, comprising: transitioning a database into successive consistent versions by tracking transactions committed to the database, each committed transaction generating a further consistent version of the database at a journaled commit time; storing transaction table entries for each uncommitted transaction, each transaction table entry storing retained data values reflecting database changes; maintaining the transaction table entries for a retention period following the commit time of each transaction; presenting a logical view of the database as of a query time occurring prior to the commit time of at least one transaction by accessing the retained data values stored in the transaction table entries for the at least one transaction; organizing the transaction table entries as a linked data structure comprising undo entries each storing at least part of the retained data values; and traversing the linked data structure and selectively retrieving the retained data values stored substantially contemporaneous to the query time.
Claim 20
Dependent Claim
37 words
A method according to claim 9 , further comprising: determining the query time based on at least one of a standardized time reference, a relative time reference, and a system change number generated by each committed transaction.
Claim 21
Dependent Claim
31 words
A method according to claim 9 , wherein the data values reflect database changes to an object comprising at least one of an object, cell, row, record, table, window, and schema.
Claim 22
Dependent Claim
22 words
A method according to claim 9 , wherein the transaction comprises at least one of a select, join, and union database operation.
Claim 23
Dependent Claim
126 words
A computer-readable storage medium holding code for providing fine-grained temporal database access in a consistent read environment, comprising: transitioning a database into successive consistent versions by tracking transactions committed to the database, each committed transaction generating a further consistent version of the database at a journaled commit time; storing transaction table entries for each uncommitted transaction, each transaction table entry storing retained data values reflecting database changes; maintaining the transaction table entries for a user-definable retention period following the commit time of each transaction; and presenting a logical view of the database as of a query time occurring prior to the commit time of at least one transaction by accessing the retained data values stored in the transaction table entries for the at least one transaction.
Claim 24
Dependent Claim
126 words
A computer-readable storage medium holding code for providing fine-grained temporal database access in a consistent read environment, comprising: transitioning a database into successive consistent versions by tracking transactions committed to the database, each committed transaction generating a further consistent version of the database at a journaled commit time; storing transaction table entries for each uncommitted transaction, each transaction table entry storing retained data values reflecting database changes; maintaining the transaction table entries for a user-definable retention period following the commit time of each transaction; and presenting a logical view of the database as of a query time occurring prior to the commit time of at least one transaction by accessing the retained data values stored in the transaction table entries for the at least one transaction.
Claim 25
Dependent Claim
50 words
A storage medium according to claim 17 , wherein each transaction table entry further comprises a transaction identifier, further comprising: selectively retrieving the retained data values from the transaction table entries for only those such at least one transaction corresponding to a transaction identifier substantially contemporaneous to the query time.
Claim 26
Dependent Claim
146 words
A computer-readable storage medium holding code for providing fine-grained temporal database access in a consistent read environment, comprising: transitioning a database into successive consistent versions by tracking transactions committed to the database, each committed transaction generating a further consistent version of the database at a journaled commit time; storing transaction table entries for each uncommitted transaction, each transaction table entry storing retained data values reflecting database changes; maintaining the transaction table entries for a retention period following the commit time of each transaction; presenting a logical view of the database as of a query time occurring prior to the commit time of at least one transaction by accessing the retained data values stored in the transaction table entries for the at least one transaction; and storing the retained data values into transaction table entries for each individual row within the database effected by an uncommitted transaction.
Claim 27
Dependent Claim
146 words
A computer-readable storage medium holding code for providing fine-grained temporal database access in a consistent read environment, comprising: transitioning a database into successive consistent versions by tracking transactions committed to the database, each committed transaction generating a further consistent version of the database at a journaled commit time; storing transaction table entries for each uncommitted transaction, each transaction table entry storing retained data values reflecting database changes; maintaining the transaction table entries for a retention period following the commit time of each transaction; presenting a logical view of the database as of a query time occurring prior to the commit time of at least one transaction by accessing the retained data values stored in the transaction table entries for the at least one transaction; and storing the retained data values into transaction table entries for each individual row within the database effected by an uncommitted transaction.
Claim 28
Dependent Claim
42 words
A storage medium according to claim 19 , further comprising: generating a logical view of an individual row within the database by accessing the retained data values stored in the transaction table entries for each such transaction having effected that individual row.
Claim 29
Dependent Claim
167 words
A computer-readable storage medium holding code for providing fine-grained temporal database access in a consistent read environment, comprising: transitioning a database into successive consistent versions by tracking transactions committed to the database, each committed transaction generating a further consistent version of the database at a journaled commit time; storing transaction table entries for each uncommitted transaction, each transaction table entry storing retained data values reflecting database changes; maintaining the transaction table entries for a retention period following the commit time of each transaction; presenting a logical view of the database as of a query time occurring prior to the commit time of at least one transaction by accessing the retained data values stored in the transaction table entries for the at least one transaction; organizing the transaction table entries as a linked data structure comprising undo entries each storing at least part of the retained data values; and traversing the linked data structure and selectively retrieving the retained data values stored substantially contemporaneous to the query time.
Claim 30
Dependent Claim
167 words
A computer-readable storage medium holding code for providing fine-grained temporal database access in a consistent read environment, comprising: transitioning a database into successive consistent versions by tracking transactions committed to the database, each committed transaction generating a further consistent version of the database at a journaled commit time; storing transaction table entries for each uncommitted transaction, each transaction table entry storing retained data values reflecting database changes; maintaining the transaction table entries for a retention period following the commit time of each transaction; presenting a logical view of the database as of a query time occurring prior to the commit time of at least one transaction by accessing the retained data values stored in the transaction table entries for the at least one transaction; organizing the transaction table entries as a linked data structure comprising undo entries each storing at least part of the retained data values; and traversing the linked data structure and selectively retrieving the retained data values stored substantially contemporaneous to the query time.
Claim 31
Dependent Claim
38 words
A storage medium according to claim 17 , further comprising: determining the query time based on at least one of a standardized time reference, a relative time reference, and a system change number generated by each committed transaction.
Claim 32
Independent Claim
159 words
A system for selectively viewing temporal row data in a consistent read-implemented database, comprising: a database engine tracking committed transactions effecting row data changes to a database, assigning a stored system change number upon each committed transaction, and transitioning the database into successive consistent versions responsive to each committed transaction at a journaled commit time; a storage storing rollback segments for uncommitted transactions, each rollback segment storing a transaction identifier and transaction table entries containing ordered row data values reflecting the database changes; a rollback mechanism maintaining the transaction table entries for a user-definable retention period following the commit time of each committed transaction; a consistent read mechanism performing a queried selection of row data values from the database as of a query time occurring prior to the commit time of at least one committed transaction and retrieving the ordered row data values contained in the rollback segments storing a transaction identifier for the at least one committed transaction.
Claim 33
Independent Claim
159 words
A system for selectively viewing temporal row data in a consistent read-implemented database, comprising: a database engine tracking committed transactions effecting row data changes to a database, assigning a stored system change number upon each committed transaction, and transitioning the database into successive consistent versions responsive to each committed transaction at a journaled commit time; a storage storing rollback segments for uncommitted transactions, each rollback segment storing a transaction identifier and transaction table entries containing ordered row data values reflecting the database changes; a rollback mechanism maintaining the transaction table entries for a user-definable retention period following the commit time of each committed transaction; a consistent read mechanism performing a queried selection of row data values from the database as of a query time occurring prior to the commit time of at least one committed transaction and retrieving the ordered row data values contained in the rollback segments storing a transaction identifier for the at least one committed transaction.
Claim 34
Dependent Claim
25 words
A system according to claim 23 , further comprising: the storage storing information pertaining to effecting or restoring the database changes into each rollback segment.
Claim 35
Dependent Claim
36 words
A system according to claim 23 , further comprising: the consistent read mechanism selecting the transaction table entries as of the query time by at least one of the commit time and the system change number.
Claim 36
Independent Claim
147 words
A method for selectively viewing temporal row data in a consistent read-implemented database, comprising: tracking committed transactions effecting row data changes to a database and assigning a stored system change number upon each committed transaction; storing rollback segments for uncommitted transactions, each rollback segment storing a transaction identifier and transaction table entries containing ordered row data values reflecting the database changes; transitioning the database into successive consistent versions responsive to each committed transaction at a journaled commit time; maintaining the transaction table entries for a user-definable retention period following the commit time of each committed transaction; performing a queried selection of row data values from the database as of a query time occurring prior to the commit time of at least one committed transaction; and retrieving the ordered row data values contained in the rollback segments storing a transaction identifier for the at least one committed transaction.
Claim 37
Independent Claim
147 words
A method for selectively viewing temporal row data in a consistent read-implemented database, comprising: tracking committed transactions effecting row data changes to a database and assigning a stored system change number upon each committed transaction; storing rollback segments for uncommitted transactions, each rollback segment storing a transaction identifier and transaction table entries containing ordered row data values reflecting the database changes; transitioning the database into successive consistent versions responsive to each committed transaction at a journaled commit time; maintaining the transaction table entries for a user-definable retention period following the commit time of each committed transaction; performing a queried selection of row data values from the database as of a query time occurring prior to the commit time of at least one committed transaction; and retrieving the ordered row data values contained in the rollback segments storing a transaction identifier for the at least one committed transaction.
Claim 38
Dependent Claim
23 words
A method according to claim 26 , further comprising: storing information pertaining to effecting or restoring the database changes into each rollback segment.
Claim 39
Dependent Claim
32 words
A method according to claim 26 , further comprising: selecting the transaction table entries as of the query time by at least one of the commit time and the system change number.
Claim 40
Dependent Claim
151 words
A computer-readable storage medium holding code for selectively viewing temporal row data in a consistent read-implemented database, comprising: tracking committed transactions effecting row data changes to a database and assigning a stored system change number upon each committed transaction; storing rollback segments for uncommitted transactions, each rollback segment storing a transaction identifier and transaction table entries containing ordered row data values reflecting the database changes; transitioning the database into successive consistent versions responsive to each committed transaction at a journaled commit time; maintaining the transaction table entries for a user-definable retention period following the commit time of each committed transaction; performing a queried selection of row data values from the database as of a query time occurring prior to the commit time of at least one committed transaction; and retrieving the ordered row data values contained in the rollback segments storing a transaction identifier for the at least one committed transaction.
Claim 41
Dependent Claim
151 words
A computer-readable storage medium holding code for selectively viewing temporal row data in a consistent read-implemented database, comprising: tracking committed transactions effecting row data changes to a database and assigning a stored system change number upon each committed transaction; storing rollback segments for uncommitted transactions, each rollback segment storing a transaction identifier and transaction table entries containing ordered row data values reflecting the database changes; transitioning the database into successive consistent versions responsive to each committed transaction at a journaled commit time; maintaining the transaction table entries for a user-definable retention period following the commit time of each committed transaction; performing a queried selection of row data values from the database as of a query time occurring prior to the commit time of at least one committed transaction; and retrieving the ordered row data values contained in the rollback segments storing a transaction identifier for the at least one committed transaction.
Claim 42
Dependent Claim
24 words
A storage medium according to claim 29 , further comprising: storing information pertaining to effecting or restoring the database changes into each rollback segment.
Claim 43
Dependent Claim
33 words
A storage medium according to claim 29 , further comprising: selecting the transaction table entries as of the query time by at least one of the commit time and the system change number.
Claim 44
Independent Claim
202 words
A system for performing a logical select operation on temporal row data stored in a consistent read-implemented database, comprising: a record of database operations comprising transactions effecting row data changes that have been committed into a database; stored rollback segments for uncommitted transactions, each rollback segment storing a transaction identifier and information pertaining to effecting or restoring the database changes, including addresses for undo entries containing row data values reflecting the database changes; a database engine transitioning the database into successive consistent database versions responsive to each committed transaction at a journaled commit time and assigning a system change number to the database version upon each committed transaction; a rollback mechanism retaining the transaction table entries for a user-definable retention period following the commit time of each committed transaction; a query engine executing a logical select operation on the database for row data values as of a query time occurring prior to the commit time of at least one committed transaction; and a consistent read mechanism retrieving the ordered row data values stored in the undo entries by referencing the undo block at each address included in the interested transaction entry with the transaction identifier for the at least one committed transaction.
Claim 45
Independent Claim
202 words
A system for performing a logical select operation on temporal row data stored in a consistent read-implemented database, comprising: a record of database operations comprising transactions effecting row data changes that have been committed into a database; stored rollback segments for uncommitted transactions, each rollback segment storing a transaction identifier and information pertaining to effecting or restoring the database changes, including addresses for undo entries containing row data values reflecting the database changes; a database engine transitioning the database into successive consistent database versions responsive to each committed transaction at a journaled commit time and assigning a system change number to the database version upon each committed transaction; a rollback mechanism retaining the transaction table entries for a user-definable retention period following the commit time of each committed transaction; a query engine executing a logical select operation on the database for row data values as of a query time occurring prior to the commit time of at least one committed transaction; and a consistent read mechanism retrieving the ordered row data values stored in the undo entries by referencing the undo block at each address included in the interested transaction entry with the transaction identifier for the at least one committed transaction.
Claim 46
Independent Claim
190 words
A method for performing a logical select operation on temporal row data stored in a consistent read-implemented database, comprising: maintaining a record of database operations comprising transactions effecting row data changes that have been committed into a database; storing rollback segments for uncommitted transactions, each rollback segment storing a transaction identifier and information pertaining to effecting or restoring the database changes, including addresses for undo entries containing row data values reflecting the database changes; transitioning the database into successive consistent database versions responsive to each committed transaction at a journaled commit time and assigning a system change number to the database version upon each committed transaction; retaining the transaction table entries for a user-definable retention period following the commit time of each committed transaction; executing a logical select operation on the database for row data values as of a query time occurring prior to the commit time of at least one committed transaction; and retrieving the ordered row data values stored in the undo entries by referencing the undo block at each address included in the interested transaction entry with the transaction identifier for the at least one committed transaction.
Claim 47
Independent Claim
190 words
A method for performing a logical select operation on temporal row data stored in a consistent read-implemented database, comprising: maintaining a record of database operations comprising transactions effecting row data changes that have been committed into a database; storing rollback segments for uncommitted transactions, each rollback segment storing a transaction identifier and information pertaining to effecting or restoring the database changes, including addresses for undo entries containing row data values reflecting the database changes; transitioning the database into successive consistent database versions responsive to each committed transaction at a journaled commit time and assigning a system change number to the database version upon each committed transaction; retaining the transaction table entries for a user-definable retention period following the commit time of each committed transaction; executing a logical select operation on the database for row data values as of a query time occurring prior to the commit time of at least one committed transaction; and retrieving the ordered row data values stored in the undo entries by referencing the undo block at each address included in the interested transaction entry with the transaction identifier for the at least one committed transaction.
Claim 48
Independent Claim
59 words
A method for processing data, comprising: receiving a query requesting temporal access of data and specifying a time prior to a commit time of a transaction that modified the data; reconstructing the data as of the time prior to the commit time of the transaction that modified the data; and completing processing the query based on the reconstructed data.
Claim 49
Independent Claim
59 words
A method for processing data, comprising: receiving a query requesting temporal access of data and specifying a time prior to a commit time of a transaction that modified the data; reconstructing the data as of the time prior to the commit time of the transaction that modified the data; and completing processing the query based on the reconstructed data.
Claim 50
Dependent Claim
19 words
A method according to claim 34 , wherein the time is specified by means of a standardized time reference.
Claim 51
Dependent Claim
20 words
A method according to claim 34 , wherein the time is specified to be relative to a standardized time reference.
Claim 52
Dependent Claim
19 words
A method according to claim 34 , wherein the time is specified by means of a system change number.
Claim 53
Dependent Claim
33 words
A computer-readable medium bearing instructions for processing data, wherein the instructions are arranged to cause a computer system, upon execution thereof, to perform the steps of the method according to claim 34 .
Claim 54
Independent Claim
74 words
A system for processing data, comprising: a database server configured to receive a query requesting temporal access of data and specifying a time prior to a commit time of a transaction that modified the data; a rollback mechanism configured to reconstruct the data as of the time prior to the commit time of the transaction that modified the data; and a query engine configured to complete processing the query based on the reconstructed data.
Claim 55
Independent Claim
74 words
A system for processing data, comprising: a database server configured to receive a query requesting temporal access of data and specifying a time prior to a commit time of a transaction that modified the data; a rollback mechanism configured to reconstruct the data as of the time prior to the commit time of the transaction that modified the data; and a query engine configured to complete processing the query based on the reconstructed data.
Claim 56
Dependent Claim
19 words
A system according to claim 39 , wherein the time is specified by means of a standardized time reference.
Claim 57
Dependent Claim
20 words
A system according to claim 39 , wherein the time is specified to be relative to a standardized time reference.
Claim 58
Dependent Claim
19 words
A system according to claim 39 , wherein the time is specified by means of a system change number.
Claim 59
Independent Claim
69 words
A method for processing data, comprising: receiving a query requesting access of data existing as of a time specified by the query; wherein the time specified is a wall clock time or a time interval relative to a current wall clock time and prior to a commit time that modified the data; obtaining the data as of the time; and completing processing the query based on the obtained data.
Claim 60
Independent Claim
69 words
A method for processing data, comprising: receiving a query requesting access of data existing as of a time specified by the query; wherein the time specified is a wall clock time or a time interval relative to a current wall clock time and prior to a commit time that modified the data; obtaining the data as of the time; and completing processing the query based on the obtained data.
References Cited (Backward Citations)
US5440730A
Cited
US5317731A
Cited
US5347653A
Cited
US5701480A
Cited
US5280612A
Cited
US5974427A
Cited
FR2746526A1
Cited
US5907848A
Cited
US5956731A
Cited
US5873102A
Cited
US5890167A
Cited
US6012060A
Cited
US6018746A
Cited
US6192377B1
Cited
US6138121A
Cited
US6449624B1
Cited
USPTO Annuity & Maintenance Windows
| Annuity Stage | Window Opens | Payment Deadline | Surcharge Period Until | Estimated Fee | Status |
|---|---|---|---|---|---|
| 3.5 Years (Year 4) | 2006-10-06 | 2007-04-07 | 2007-10-07 | $2000.00 | Window Closed / Lapsed |
| 7.5 Years (Year 8) | 2010-10-06 | 2011-04-07 | 2011-10-07 | $3760.00 | Window Closed / Lapsed |
| 11.5 Years (Year 12) | 2014-10-06 | 2015-04-07 | 2015-10-07 | $7700.00 | Window Closed / Lapsed |