Consistent client-side cache

Patent metadata

Field	Value
Publication number	US-9697253-B2
Application number	US-87578207-A
Country	US
Kind code	B2
Filing date	Oct 19, 2007
Priority date	Oct 20, 2006
Publication date	Jul 4, 2017
Grant date	Jul 4, 2017

Abstract

A method, system, and computer program product is disclosed for caching results in a client-side cache. Embodiments of a method, a system, and a computer program product are disclosed that associate a first snapshot of a database with a client that indicates a state of the database after a last database request by the client, and indicate any number of invalid cached results in the client cache for the client based upon the first snapshot. In some embodiments, the method further includes receiving a second snapshot that indicates a state of the database upon receipt of a database server request by the client, and updating the first snapshot with the second snapshot.

First claim

What is claimed is:

1. A computer implemented method for caching query results in a client-side cache, comprising:
identifying data stored on a database at a database server, the data comprising a first table and a second table, wherein a change in the second table executes a trigger that automatically modifies at least a portion of the first table that corresponds to the change in the second table;
maintaining the query results at the client-side cache for a query, wherein the query results correspond to the first table and the second table stored on the database at the database server;
sending, by using a processor, a database server request to the database server from a client, wherein the database server request is directed to a change in the second table stored on the database, the change in the second table executing the trigger that automatically modifies at least the portion of the first table to correspond to the change in the second table;
receiving query results from the database server from processing the database server request, in which the database server also sends information pertaining to whether the query results cached at the client-side cache are invalid, wherein determining whether the query results are invalid comprises: (a) accessing a set of query registrations, a query registration from among the set of query registrations comprising a query identification along with identification of one or more database objects corresponding to the query identification, wherein first snapshot data is associated with the one or more database objects corresponding to the query identification, (b) comparing the first snapshot data with second snapshot data, the second snapshot data associated with a latest version of the one or more objects registered for the query identification; and (c) sending a response back to the client to invalidate the query results if comparison of the first snapshot data with the second snapshot data indicates a change to any of the one or more objects corresponding to the query identification that is specified to cause an invalidation of the query results for the query identification;
wherein the query results were registered based upon a determination that the query should be cached by: (a) analyzing the query based at least on one or more of a size of a result of the query, whether a result of the query relies on data from read only or mostly read tables, a frequency expectation for a repeat of the query, a frequency expectation for a change in the query results, a constraint specified by the client, or an amount of computing expenses required to compute the query results; and (b) registering the query result at the server if it is determined that the query should be cached; and
storing the information in a non-transitory computer-usable medium or displaying the information on a display device.

2. The method of claim 1 , further comprising:
sending from the client a first reference information with the database server request indicating a state of the database after a previous database server request by the client;
receiving at the client a second reference information with the results indicating a current state of the database; and
updating the first reference information with the second reference information.

3. The method of claim 1 , further comprising:
invalidating some or all of the one or more cached results that have been indicated as invalid for a client session, wherein the some or all of the one or more cached results includes cached results for the client session that relate to uncommitted database changes made by the client with the client session.

4. The method of claim 2 further comprising:
receiving any number of cached result identifiers, wherein the any number of cached result identifiers relate to transactions that occurred between the first reference information and the second reference information; and
invalidating any number of invalid cached results associated with the any number of cached result identifiers.

5. The method of claim 1 , further comprising:
determining at the client whether the query results at the client-side cache are invalid, wherein a cache manager accesses the client-side cache.

6. The method of claim 4 , wherein the any number of cached result identifiers are query identifications.

7. The method of claim 1 , wherein invalid cached results further comprise invalid results due to a change in environment settings.

8. The method of claim 1 , wherein invalid cached results further comprise invalid cached result identifiers for database changes made by transactions other than those issued by the client.

9. The method of claim 1 , wherein invalid cached results further comprise at least one cached result identifier associated with a snapshot of the database at creation time of at least one invalid cached result identifier.

10. The method of claim 1 , wherein the snapshot data comprises at least data corresponding to a record of a state of the database for a committed transaction.

11. The method of claim 1 , wherein invalid cached results are retained by the client along with a snapshot of the database at a creation time of an invalid cached result, wherein the invalid cached results are result sets associated with invalid cached result identifiers.

12. The method of claim 1 , further comprising a maximum cache lag, wherein the cache is not accessed if the maximum cache lag is exceeded.

13. The method of claim 1 , further comprising:
determining if a query result needs to be cached, wherein the query result is designated to be cached at the client using one or more of the following: a data description language command, a query command or a database application programming interface; and
caching the query result based at least in part upon an act of determining.

14. The method of claim 1 , wherein the database server determines whether the query results at the client-side cache are invalid.

15. The method of claim 1 , further comprising:
responsive to determining the one or more query results are not cacheworthy, updating the client-side cache with information describing a set of invalid query results cached at the client-side cache;
identifying one or more invalid query results cached at the client-side cache based at least in part on one or more query identifications associated with a change in data stored on the database;
performing garbage collection after abnormal termination of the client;
wherein the information pertaining to whether the query results cached at the client-side cache are invalid is based at least in part on information describing transactions received from a database broadcast to additional database instances within a database cluster;
wherein the client is connected to a plurality of databases, where at least some of the databases are identified based on one or more of a database name, a database creation timestamp, a database startup time, and a globally unique identifier; and
wherein the client is included in a plurality of clients connected to the database server.

16. A computer program product comprising a non-transitory computer usable medium having executable code to execute, by using a processor, a process for implementing a client cache in a computing system, the process comprising:
identifying data stored on a database at a database server, the data comprising a first table and a second table, wherein a change in the second table executes a trigger that automatically modifies at least a portion of the first table that corresponds to the change in the second table;
mainta

Assignees

• Chidambaran Lakshminarayanan
• Bastawala Mehul Dilip
• Krishnaswamy Srinath
• Lahiri Tirthankar
• Loaiza Juan R
• Sinha Bipul
• Vemuri Srinivas S
• Oracle Int Corp

Inventors

• Chidambaran Lakshminarayanan
• Bastawala Mehul Dilip
• Krishnaswamy Srinath
• Lahiri Tirthankar
• Loaiza Juan R
• Sinha Bipul
• Vemuri Srinivas S

Classifications

• G06F16/24552 Primary

  Database cache management · CPC title

• G06F17/3048 Primary

  Physics · mapped topic