Package mondrian.rolap.agg

Class SegmentCacheManager

java.lang.Object

mondrian.rolap.agg.SegmentCacheManager

public class SegmentCacheManager
extends Object

Nested Class Summary

Nested Classes

Modifier and Type	Class	Description
static class	SegmentCacheManager.AbortException	Exception which someone can throw to indicate to the Actor that whatever it was doing is not needed anymore.
static class	SegmentCacheManager.Command<T>
static class	SegmentCacheManager.FlushCommand	Command to flush a particular region from cache.
static class	SegmentCacheManager.FlushResult	Result of a SegmentCacheManager.FlushCommand.
class	SegmentCacheManager.SegmentCacheIndexRegistry	Registry of all the indexes that were created for this cache manager, per RolapStar.
static interface	SegmentCacheManager.Visitor	Visitor for messages (commands and events).

Field Summary

Fields

Modifier and Type	Field	Description
ExecutorService	cacheExecutor	Executor with which to send requests to external caches.
SegmentCache	compositeCache
List<SegmentCacheWorker>	segmentCacheWorkers
ExecutorService	sqlExecutor	Executor with which to execute SQL requests.
Thread	thread

Constructor Summary

Constructors

Constructor	Description
SegmentCacheManager(MondrianServer server)

Method Summary

Modifier and Type	Method	Description
<T> T	execute(SegmentCacheManager.Command<T> command)
void	externalSegmentCreated(SegmentHeader header, MondrianServer server)	Tells the cache that a segment is newly available in an external cache.
void	externalSegmentDeleted(SegmentHeader header, MondrianServer server)	Tells the cache that a segment is no longer available in an external cache.
SegmentBuilder.SegmentConverter	getConverter(RolapStar star, SegmentHeader header)
SegmentCacheManager.SegmentCacheIndexRegistry	getIndexRegistry()
boolean	loadCacheForStar(RolapStar star)	Load external cached elements for received star.
void	loadFailed(RolapStar star, SegmentHeader header, Throwable throwable)	Informs cache manager that a segment load failed.
void	loadSucceeded(RolapStar star, SegmentHeader header, SegmentBody body)	Adds a segment to segment index.
SegmentWithData	peek(CellRequest request)	Makes a quick request to the aggregation manager to see whether the cell value required by a particular cell request is in external cache.
void	printCacheState(CacheControl.CellRegion region, PrintWriter pw, Locus locus)
void	remove(RolapStar star, SegmentHeader header)	Removes a segment from segment index.
void	shutdown()	Shuts down this cache manager and all active threads and indexes.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

thread

public final Thread thread

cacheExecutor

public final ExecutorService cacheExecutor

Executor with which to send requests to external caches.

sqlExecutor

public final ExecutorService sqlExecutor

Executor with which to execute SQL requests.

TODO: create using factory and/or configuration parameters. Executor should be shared within MondrianServer or target JDBC database.

segmentCacheWorkers

public final List<SegmentCacheWorker> segmentCacheWorkers

compositeCache

public final SegmentCache compositeCache

Constructor Detail

SegmentCacheManager

public SegmentCacheManager(MondrianServer server)

Method Detail

loadCacheForStar

public boolean loadCacheForStar(RolapStar star)

Load external cached elements for received star. Similar to externalSegmentCreated but the index is created if not there.

Parameters:

star - the star for which the cache is loaded

Returns:

true if elements existed for this star.

execute

public <T> T execute(SegmentCacheManager.Command<T> command)

getIndexRegistry

public SegmentCacheManager.SegmentCacheIndexRegistry getIndexRegistry()

loadSucceeded

public void loadSucceeded(RolapStar star,
                          SegmentHeader header,
                          SegmentBody body)

Adds a segment to segment index.

Called when a SQL statement has finished loading a segment.

Does not add the segment to the external cache. That is a potentially long-duration operation, better carried out by a worker.

Parameters:

header - segment header

body - segment body

loadFailed

public void loadFailed(RolapStar star,
                       SegmentHeader header,
                       Throwable throwable)

Informs cache manager that a segment load failed.

Called when a SQL statement receives an error while loading a segment.

Parameters:

header - segment header

throwable - Error

remove

public void remove(RolapStar star,
                   SegmentHeader header)

Removes a segment from segment index.

Call is asynchronous. It comes back immediately.

Does not remove it from the external cache.

Parameters:

header - segment header

externalSegmentCreated

public void externalSegmentCreated(SegmentHeader header,
                                   MondrianServer server)

Tells the cache that a segment is newly available in an external cache.

externalSegmentDeleted

public void externalSegmentDeleted(SegmentHeader header,
                                   MondrianServer server)

Tells the cache that a segment is no longer available in an external cache.

printCacheState

public void printCacheState(CacheControl.CellRegion region,
                            PrintWriter pw,
                            Locus locus)

shutdown

public void shutdown()

Shuts down this cache manager and all active threads and indexes.

getConverter

public SegmentBuilder.SegmentConverter getConverter(RolapStar star,
                                                    SegmentHeader header)

peek

public SegmentWithData peek(CellRequest request)

Makes a quick request to the aggregation manager to see whether the cell value required by a particular cell request is in external cache.

'Quick' is relative. It is an asynchronous request (due to the aggregation manager being an actor) and therefore somewhat slow. If the segment is in cache, will save batching up future requests and re-executing the query. Win should be particularly noticeable for queries running on a populated cache. Without this feature, every query would require at least two iterations.

Request does not issue SQL to populate the segment. Nor does it try to find existing segments for rollup. Those operations can wait until next phase.

Client is responsible for adding the segment to its private cache.

Parameters:

request - Cell request

Returns:

Segment with data, or null if not in cache