JobStoreSupport (Quartz Enterprise Job Scheduler 2.3.1-SNAPSHOT API)

java.lang.Object
- org.quartz.impl.jdbcjobstore.JobStoreSupport

All Implemented Interfaces:

Constants, JobStore

Direct Known Subclasses:

JobStoreCMT, JobStoreTX
```
public abstract class JobStoreSupport
extends Object
implements JobStore, Constants
```
Contains base functionality for JDBC-based JobStore implementations.

Author:

Jeffrey Wescott, James House

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`protected static class`	`JobStoreSupport.RecoverMisfiredJobsResult` Helper class for returning the composite result of trying to recover misfired jobs.
`protected static interface`	`JobStoreSupport.TransactionCallback<T>` Implement this interface to provide the code to execute within the a transaction template.
`protected static interface`	`JobStoreSupport.TransactionValidator<T>`
`protected class`	`JobStoreSupport.VoidTransactionCallback` Implement this interface to provide the code to execute within the a transaction template that has no return value.

Field Summary

Fields
Modifier and Type	Field and Description
`protected HashMap<String,Calendar>`	`calendarCache`
`protected Class<? extends DriverDelegate>`	`delegateClass`
`protected String`	`delegateClassName`
`protected String`	`delegateInitString`
`protected String`	`dsName`
`protected boolean`	`firstCheckIn`
`protected String`	`instanceId`
`protected String`	`instanceName`
`protected long`	`lastCheckin`
`protected static String`	`LOCK_STATE_ACCESS`
`protected static String`	`LOCK_TRIGGER_ACCESS`
`protected int`	`maxToRecoverAtATime`
`protected ThreadLocal<Long>`	`sigChangeForTxCompletion`
`protected String`	`tablePrefix`
`protected boolean`	`useProperties`

Fields inherited from interface org.quartz.impl.jdbcjobstore.Constants
ALIAS_COL_NEXT_FIRE_TIME, ALL_GROUPS_PAUSED, COL_BLOB, COL_CALENDAR, COL_CALENDAR_NAME, COL_CHECKIN_INTERVAL, COL_CRON_EXPRESSION, COL_DESCRIPTION, COL_END_TIME, COL_ENTRY_ID, COL_ENTRY_STATE, COL_FIRED_TIME, COL_INSTANCE_NAME, COL_IS_DURABLE, COL_IS_NONCONCURRENT, COL_IS_UPDATE_DATA, COL_IS_VOLATILE, COL_JOB_CLASS, COL_JOB_DATAMAP, COL_JOB_GROUP, COL_JOB_NAME, COL_LAST_CHECKIN_TIME, COL_LOCK_NAME, COL_MISFIRE_INSTRUCTION, COL_NEXT_FIRE_TIME, COL_PREV_FIRE_TIME, COL_PRIORITY, COL_REPEAT_COUNT, COL_REPEAT_INTERVAL, COL_REQUESTS_RECOVERY, COL_SCHED_TIME, COL_SCHEDULER_NAME, COL_START_TIME, COL_TIME_ZONE_ID, COL_TIMES_TRIGGERED, COL_TRIGGER_GROUP, COL_TRIGGER_NAME, COL_TRIGGER_STATE, COL_TRIGGER_TYPE, DEFAULT_TABLE_PREFIX, STATE_ACQUIRED, STATE_BLOCKED, STATE_COMPLETE, STATE_DELETED, STATE_ERROR, STATE_EXECUTING, STATE_MISFIRED, STATE_PAUSED, STATE_PAUSED_BLOCKED, STATE_WAITING, TABLE_BLOB_TRIGGERS, TABLE_CALENDARS, TABLE_CRON_TRIGGERS, TABLE_FIRED_TRIGGERS, TABLE_JOB_DETAILS, TABLE_LOCKS, TABLE_PAUSED_TRIGGERS, TABLE_SCHEDULER_STATE, TABLE_SIMPLE_TRIGGERS, TABLE_TRIGGERS, TTYPE_BLOB, TTYPE_CAL_INT, TTYPE_CRON, TTYPE_DAILY_TIME_INT, TTYPE_SIMPLE

Constructor Summary

Constructors
Constructor and Description

JobStoreSupport()

Constructors
Constructor and Description
`JobStoreSupport()`

Method Summary

All Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`protected List<OperableTrigger>`	`acquireNextTrigger(Connection conn, long noLaterThan, int maxCount, long timeWindow)`
`List<OperableTrigger>`	`acquireNextTriggers(long noLaterThan, int maxCount, long timeWindow)` Get a handle to the next N triggers to be fired, and mark them as 'reserved' by the calling scheduler.
`protected long`	`calcFailedIfAfter(SchedulerStateRecord rec)`
`protected boolean`	`calendarExists(Connection conn, String calName)`
`boolean`	`canUseProperties()` Get whether String-only properties will be handled in JobDataMaps.
`protected String`	`checkBlockedState(Connection conn, JobKey jobKey, String currentState)` Determines if a Trigger for the given job should be blocked.
`protected boolean`	`checkExists(Connection conn, JobKey jobKey)`
`protected boolean`	`checkExists(Connection conn, TriggerKey triggerKey)`
`boolean`	`checkExists(JobKey jobKey)` Determine whether a `Job` with the given identifier already exists within the scheduler.
`boolean`	`checkExists(TriggerKey triggerKey)` Determine whether a `Trigger` with the given identifier already exists within the scheduler.
`protected void`	`cleanupConnection(Connection conn)` Cleanup the given database connection.
`void`	`clearAllSchedulingData()` Clear (delete!) all scheduling data - all `Job`s, `Trigger`s `Calendar`s.
`protected void`	`clearAllSchedulingData(Connection conn)`
`protected Long`	`clearAndGetSignalSchedulingChangeOnTxCompletion()`
`protected void`	`closeConnection(Connection conn)` Closes the supplied `Connection`.
`protected List<SchedulerStateRecord>`	`clusterCheckIn(Connection conn)`
`protected void`	`clusterRecover(Connection conn, List<SchedulerStateRecord> failedInstances)`
`protected void`	`commitConnection(Connection conn)` Commit the supplied connection
`protected boolean`	`doCheckin()`
`protected JobStoreSupport.RecoverMisfiredJobsResult`	`doRecoverMisfires()`
`protected abstract <T> T`	`executeInLock(String lockName, JobStoreSupport.TransactionCallback<T> txCallback)` Execute the given callback having acquired the given lock.
`protected <T> T`	`executeInNonManagedTXLock(String lockName, JobStoreSupport.TransactionCallback<T> txCallback, JobStoreSupport.TransactionValidator<T> txValidator)` Execute the given callback having optionally acquired the given lock.
`<T> T`	`executeWithoutLock(JobStoreSupport.TransactionCallback<T> txCallback)` Execute the given callback in a transaction.
`protected List<SchedulerStateRecord>`	`findFailedInstances(Connection conn)` Get a list of all scheduler instances in the cluster that may have failed.
`long`	`getAcquireRetryDelay(int failureCount)` Get the amount of time (in ms) to wait when accessing this job store repeatedly fails.
`protected Connection`	`getAttributeRestoringConnection(Connection conn)` Wrap the given `Connection` in a Proxy such that attributes that might be set will be restored before the connection is closed (and potentially restored to a pool).
`List<String>`	`getCalendarNames()` Get the names of all of the `Calendar` s in the `JobStore`.
`protected List<String>`	`getCalendarNames(Connection conn)`
`protected ClassLoadHelper`	`getClassLoadHelper()`
`long`	`getClusterCheckinInterval()` Get the frequency (in milliseconds) at which this instance "checks-in" with the other instances of the cluster.
`protected Connection`	`getConnection()`
`String`	`getDataSource()` Get the name of the `DataSource` that should be used for performing database functions.
`long`	`getDbRetryInterval()`
`protected DriverDelegate`	`getDelegate()` Get the driver delegate for DB operations.
`boolean`	`getDoubleCheckLockMisfireHandler()` Get whether to check to see if there are Triggers that have misfired before actually acquiring the lock to recover them.
`String`	`getDriverDelegateClass()` Get the JDBC driver delegate class name.
`String`	`getDriverDelegateInitString()` Get the JDBC driver delegate's initialization string.
`long`	`getEstimatedTimeToReleaseAndAcquireTrigger()` How long (in milliseconds) the `JobStore` implementation estimates that it will take to release a trigger and acquire a new one.
`protected String`	`getFiredTriggerRecordId()`
`String`	`getInstanceId()` Get the instance Id of the Scheduler (must be unique within a cluster).
`String`	`getInstanceName()` Get the instance name of the Scheduler (must be unique within this server instance).
`List<String>`	`getJobGroupNames()` Get the names of all of the `Job` groups.
`protected List<String>`	`getJobGroupNames(Connection conn)`
`Set<JobKey>`	`getJobKeys(GroupMatcher<JobKey> matcher)` Get the names of all of the `Job` s that matcher the given groupMatcher.
`protected Set<JobKey>`	`getJobNames(Connection conn, GroupMatcher<JobKey> matcher)`
`protected Semaphore`	`getLockHandler()`
`protected org.slf4j.Logger`	`getLog()`
`boolean`	`getMakeThreadsDaemons()` Get whether the threads spawned by this JobStore should be marked as daemon.
`int`	`getMaxMisfiresToHandleAtATime()` Get the maximum number of misfired triggers that the misfire handling thread will try to recover at one time (within one transaction).
`long`	`getMisfireThreshold()`
`protected long`	`getMisfireTime()`
`protected abstract Connection`	`getNonManagedTXConnection()`
`int`	`getNumberOfCalendars()` Get the number of `Calendar` s that are stored in the `JobsStore`.
`protected int`	`getNumberOfCalendars(Connection conn)`
`int`	`getNumberOfJobs()` Get the number of `Job` s that are stored in the `JobStore`.
`protected int`	`getNumberOfJobs(Connection conn)`
`int`	`getNumberOfTriggers()` Get the number of `Trigger` s that are stored in the `JobsStore`.
`protected int`	`getNumberOfTriggers(Connection conn)`
`Set<String>`	`getPausedTriggerGroups()`
`Set<String>`	`getPausedTriggerGroups(Connection conn)` Pause all of the `Triggers` in the given group.
`String`	`getSelectWithLockSQL()`
`String`	`getTablePrefix()` Get the prefix that should be pre-pended to all table names.
`ThreadExecutor`	`getThreadExecutor()`
`List<String>`	`getTriggerGroupNames()` Get the names of all of the `Trigger` groups.
`protected List<String>`	`getTriggerGroupNames(Connection conn)`
`Set<TriggerKey>`	`getTriggerKeys(GroupMatcher<TriggerKey> matcher)` Get the names of all of the `Trigger` s that match the given group Matcher.
`protected Set<TriggerKey>`	`getTriggerNames(Connection conn, GroupMatcher<TriggerKey> matcher)`
`protected List<OperableTrigger>`	`getTriggersForJob(Connection conn, JobKey key)`
`List<OperableTrigger>`	`getTriggersForJob(JobKey jobKey)` Get all of the Triggers that are associated to the given Job.
`Trigger.TriggerState`	`getTriggerState(Connection conn, TriggerKey key)`
`Trigger.TriggerState`	`getTriggerState(TriggerKey triggerKey)` Get the current state of the identified `Trigger`.
`boolean`	`getUseDBLocks()` Get whether this instance should use database-based thread synchronization.
`void`	`initialize(ClassLoadHelper loadHelper, SchedulerSignaler signaler)` Called by the QuartzScheduler before the `JobStore` is used, in order to give it a chance to initialize.
`boolean`	`isAcquireTriggersWithinLock()` Whether or not the query and update to acquire a Trigger for firing should be performed after obtaining an explicit DB lock (to avoid possible race conditions on the trigger's db row).
`boolean`	`isClustered()` Get whether this instance is part of a cluster.
`boolean`	`isDontSetAutoCommitFalse()`
`boolean`	`isLockOnInsert()`
`boolean`	`isThreadsInheritInitializersClassLoadContext()` Get whether to set the class load context of spawned threads to that of the initializing thread.
`boolean`	`isTxIsolationLevelSerializable()`
`protected boolean`	`jobExists(Connection conn, JobKey jobKey)` Check existence of a given job.
`protected void`	`logWarnIfNonZero(int val, String warning)`
`void`	`pauseAll()` Pause all triggers - equivalent of calling `pauseTriggerGroup(group)` on every group.
`void`	`pauseAll(Connection conn)` Pause all triggers - equivalent of calling `pauseTriggerGroup(group)` on every group.
`void`	`pauseJob(JobKey jobKey)` Pause the `Job` with the given name - by pausing all of its current `Trigger`s.
`Set<String>`	`pauseJobs(GroupMatcher<JobKey> matcher)` Pause all of the `Jobs` matching the given groupMatcher - by pausing all of their `Trigger`s.
`void`	`pauseTrigger(Connection conn, TriggerKey triggerKey)` Pause the `Trigger` with the given name.
`void`	`pauseTrigger(TriggerKey triggerKey)` Pause the `Trigger` with the given name.
`Set<String>`	`pauseTriggerGroup(Connection conn, GroupMatcher<TriggerKey> matcher)` Pause all of the `Triggers` matching the given groupMatcher.
`Set<String>`	`pauseTriggers(GroupMatcher<TriggerKey> matcher)` Pause all of the `Triggers` matching the given groupMatcher.
`protected void`	`recoverJobs()` Recover any failed or misfired jobs and clean up the data store as appropriate.
`protected void`	`recoverJobs(Connection conn)` Will recover any failed or misfired jobs and clean up the data store as appropriate.
`protected JobStoreSupport.RecoverMisfiredJobsResult`	`recoverMisfiredJobs(Connection conn, boolean recovering)`
`protected void`	`releaseAcquiredTrigger(Connection conn, OperableTrigger trigger)`
`void`	`releaseAcquiredTrigger(OperableTrigger trigger)` Inform the `JobStore` that the scheduler no longer plans to fire the given `Trigger`, that it had previously acquired (reserved).
`protected void`	`releaseLock(String lockName, boolean doIt)`
`protected boolean`	`removeCalendar(Connection conn, String calName)`
`boolean`	`removeCalendar(String calName)` Remove (delete) the `Calendar` with the given name.
`protected boolean`	`removeJob(Connection conn, JobKey jobKey)`
`boolean`	`removeJob(JobKey jobKey)` Remove (delete) the `Job` with the given name, and any `Trigger` s that reference it.
`boolean`	`removeJobs(List<JobKey> jobKeys)`
`protected boolean`	`removeTrigger(Connection conn, TriggerKey key)`
`boolean`	`removeTrigger(TriggerKey triggerKey)` Remove (delete) the `Trigger` with the given name.
`boolean`	`removeTriggers(List<TriggerKey> triggerKeys)`
`protected boolean`	`replaceTrigger(Connection conn, TriggerKey key, OperableTrigger newTrigger)`
`boolean`	`replaceTrigger(TriggerKey triggerKey, OperableTrigger newTrigger)` Remove (delete) the `Trigger` with the given key, and store the new given one - which must be associated with the same job.
`void`	`resetTriggerFromErrorState(TriggerKey triggerKey)` Reset the current state of the identified `Trigger` from `Trigger.TriggerState.ERROR` to `Trigger.TriggerState.NORMAL` or `Trigger.TriggerState.PAUSED` as appropriate.
`void`	`resumeAll()` Resume (un-pause) all triggers - equivalent of calling `resumeTriggerGroup(group)` on every group.
`void`	`resumeAll(Connection conn)` protected
`void`	`resumeJob(JobKey jobKey)` Resume (un-pause) the `Job` with the given name.
`Set<String>`	`resumeJobs(GroupMatcher<JobKey> matcher)` Resume (un-pause) all of the `Jobs` in the given group.
`void`	`resumeTrigger(Connection conn, TriggerKey key)` Resume (un-pause) the `Trigger` with the given name.
`void`	`resumeTrigger(TriggerKey triggerKey)` Resume (un-pause) the `Trigger` with the given name.
`Set<String>`	`resumeTriggerGroup(Connection conn, GroupMatcher<TriggerKey> matcher)` Resume (un-pause) all of the `Triggers` matching the given groupMatcher.
`Set<String>`	`resumeTriggers(GroupMatcher<TriggerKey> matcher)` Resume (un-pause) all of the `Triggers` matching the given groupMatcher.
`protected Calendar`	`retrieveCalendar(Connection conn, String calName)`
`Calendar`	`retrieveCalendar(String calName)` Retrieve the given `Trigger`.
`protected JobDetail`	`retrieveJob(Connection conn, JobKey key)`
`JobDetail`	`retrieveJob(JobKey jobKey)` Retrieve the `JobDetail` for the given `Job`.
`protected OperableTrigger`	`retrieveTrigger(Connection conn, TriggerKey key)`
`OperableTrigger`	`retrieveTrigger(TriggerKey triggerKey)` Retrieve the given `Trigger`.
`protected <T> T`	`retryExecuteInNonManagedTXLock(String lockName, JobStoreSupport.TransactionCallback<T> txCallback)`
`protected void`	`rollbackConnection(Connection conn)` Rollback the supplied connection.
`void`	`schedulerPaused()` Called by the QuartzScheduler to inform the `JobStore` that the scheduler has been paused.
`void`	`schedulerResumed()` Called by the QuartzScheduler to inform the `JobStore` that the scheduler has resumed after being paused.
`void`	`schedulerStarted()` Called by the QuartzScheduler to inform the `JobStore` that the scheduler has started.
`void`	`setAcquireTriggersWithinLock(boolean acquireTriggersWithinLock)` Whether or not the query and update to acquire a Trigger for firing should be performed after obtaining an explicit DB lock.
`void`	`setClusterCheckinInterval(long l)` Set the frequency (in milliseconds) at which this instance "checks-in" with the other instances of the cluster.
`void`	`setDataSource(String dsName)` Set the name of the `DataSource` that should be used for performing database functions.
`void`	`setDbRetryInterval(long dbRetryInterval)`
`void`	`setDontSetAutoCommitFalse(boolean b)` Don't call set autocommit(false) on connections obtained from the DataSource.
`void`	`setDoubleCheckLockMisfireHandler(boolean doubleCheckLockMisfireHandler)` Set whether to check to see if there are Triggers that have misfired before actually acquiring the lock to recover them.
`void`	`setDriverDelegateClass(String delegateClassName)` Set the JDBC driver delegate class.
`void`	`setDriverDelegateInitString(String delegateInitString)` Set the JDBC driver delegate's initialization string.
`void`	`setInstanceId(String instanceId)` Set the instance Id of the Scheduler (must be unique within a cluster).
`void`	`setInstanceName(String instanceName)` Set the instance name of the Scheduler (must be unique within this server instance).
`void`	`setIsClustered(boolean isClustered)` Set whether this instance is part of a cluster.
`void`	`setLockHandler(Semaphore lockHandler)`
`void`	`setLockOnInsert(boolean lockOnInsert)` Whether or not to obtain locks when inserting new jobs/triggers.
`void`	`setMakeThreadsDaemons(boolean makeThreadsDaemons)` Set whether the threads spawned by this JobStore should be marked as daemon.
`void`	`setMaxMisfiresToHandleAtATime(int maxToRecoverAtATime)` Set the maximum number of misfired triggers that the misfire handling thread will try to recover at one time (within one transaction).
`void`	`setMisfireThreshold(long misfireThreshold)` The the number of milliseconds by which a trigger must have missed its next-fire-time, in order for it to be considered "misfired" and thus have its misfire instruction applied.
`void`	`setSelectWithLockSQL(String string)` set the SQL statement to use to select and lock a row in the "locks" table.
`void`	`setTablePrefix(String prefix)` Set the prefix that should be pre-pended to all table names.
`void`	`setThreadExecutor(ThreadExecutor threadExecutor)`
`void`	`setThreadPoolSize(int poolSize)` Tells the JobStore the pool size used to execute jobs
`void`	`setThreadsInheritInitializersClassLoadContext(boolean threadsInheritInitializersClassLoadContext)` Set whether to set the class load context of spawned threads to that of the initializing thread.
`void`	`setTxIsolationLevelSerializable(boolean b)` Set the transaction isolation level of DB connections to sequential.
`void`	`setUseDBLocks(boolean useDBLocks)` Set whether this instance should use database-based thread synchronization.
`void`	`setUseProperties(String useProp)` Set whether String-only properties will be handled in JobDataMaps.
`void`	`shutdown()` Called by the QuartzScheduler to inform the `JobStore` that it should free up all of it's resources because the scheduler is shutting down.
`protected void`	`signalSchedulingChangeImmediately(long candidateNewNextFireTime)`
`protected void`	`signalSchedulingChangeOnTxCompletion(long candidateNewNextFireTime)`
`protected void`	`storeCalendar(Connection conn, String calName, Calendar calendar, boolean replaceExisting, boolean updateTriggers)`
`void`	`storeCalendar(String calName, Calendar calendar, boolean replaceExisting, boolean updateTriggers)` Store the given `Calendar`.
`protected void`	`storeJob(Connection conn, JobDetail newJob, boolean replaceExisting)` Insert or update a job.
`void`	`storeJob(JobDetail newJob, boolean replaceExisting)` Store the given `JobDetail`.
`void`	`storeJobAndTrigger(JobDetail newJob, OperableTrigger newTrigger)` Store the given `JobDetail` and `Trigger`.
`void`	`storeJobsAndTriggers(Map<JobDetail,Set<? extends Trigger>> triggersAndJobs, boolean replace)`
`protected void`	`storeTrigger(Connection conn, OperableTrigger newTrigger, JobDetail job, boolean replaceExisting, String state, boolean forceState, boolean recovering)` Insert or update a trigger.
`void`	`storeTrigger(OperableTrigger newTrigger, boolean replaceExisting)` Store the given `Trigger`.
`boolean`	`supportsPersistence()`
`protected void`	`triggeredJobComplete(Connection conn, OperableTrigger trigger, JobDetail jobDetail, Trigger.CompletedExecutionInstruction triggerInstCode)`
`void`	`triggeredJobComplete(OperableTrigger trigger, JobDetail jobDetail, Trigger.CompletedExecutionInstruction triggerInstCode)` Inform the `JobStore` that the scheduler has completed the firing of the given `Trigger` (and the execution its associated `Job`), and that the `JobDataMap` in the given `JobDetail` should be updated if the `Job` is stateful.
`protected boolean`	`triggerExists(Connection conn, TriggerKey key)` Check existence of a given trigger.
`protected TriggerFiredBundle`	`triggerFired(Connection conn, OperableTrigger trigger)`
`List<TriggerFiredResult>`	`triggersFired(List<OperableTrigger> triggers)` Inform the `JobStore` that the scheduler is now firing the given `Trigger` (executing its associated `Job`), that it had previously acquired (reserved).
`protected boolean`	`updateMisfiredTrigger(Connection conn, TriggerKey triggerKey, String newStateIfNotComplete, boolean forceState)`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - LOCK_TRIGGER_ACCESS
```
protected static final String LOCK_TRIGGER_ACCESS
```
    See Also:
    
    Constant Field Values
  - LOCK_STATE_ACCESS
```
protected static final String LOCK_STATE_ACCESS
```
    See Also:
    
    Constant Field Values
  - dsName
```
protected String dsName
```
  - tablePrefix
```
protected String tablePrefix
```
  - useProperties
```
protected boolean useProperties
```
  - instanceId
```
protected String instanceId
```
  - instanceName
```
protected String instanceName
```
  - delegateClassName
```
protected String delegateClassName
```
  - delegateInitString
```
protected String delegateInitString
```
  - delegateClass
```
protected Class<? extends DriverDelegate> delegateClass
```
  - calendarCache
```
protected HashMap<String,Calendar> calendarCache
```
  - maxToRecoverAtATime
```
protected int maxToRecoverAtATime
```
  - sigChangeForTxCompletion
```
protected ThreadLocal<Long> sigChangeForTxCompletion
```
  - firstCheckIn
```
protected boolean firstCheckIn
```
  - lastCheckin
```
protected long lastCheckin
```
- Constructor Detail
  - JobStoreSupport
```
public JobStoreSupport()
```
- Method Detail
  - setDataSource
```
public void setDataSource(String dsName)
```
    Set the name of the DataSource that should be used for performing database functions.
  - getDataSource
```
public String getDataSource()
```
    Get the name of the DataSource that should be used for performing database functions.
  - setTablePrefix
```
public void setTablePrefix(String prefix)
```
    Set the prefix that should be pre-pended to all table names.
  - getTablePrefix
```
public String getTablePrefix()
```
    Get the prefix that should be pre-pended to all table names.
  - setUseProperties
```
public void setUseProperties(String useProp)
```
    Set whether String-only properties will be handled in JobDataMaps.
  - canUseProperties
```
public boolean canUseProperties()
```
    Get whether String-only properties will be handled in JobDataMaps.
  - setInstanceId
```
public void setInstanceId(String instanceId)
```
    Set the instance Id of the Scheduler (must be unique within a cluster).
    
    Specified by:
    
    setInstanceId in interface JobStore
  - getInstanceId
```
public String getInstanceId()
```
    Get the instance Id of the Scheduler (must be unique within a cluster).
  - setInstanceName
```
public void setInstanceName(String instanceName)
```
    Set the instance name of the Scheduler (must be unique within this server instance).
    
    Specified by:
    
    setInstanceName in interface JobStore
  - setThreadPoolSize
```
public void setThreadPoolSize(int poolSize)
```
    Description copied from interface: JobStore
    
    Tells the JobStore the pool size used to execute jobs
    
    Specified by:
    
    setThreadPoolSize in interface JobStore
    
    Parameters:
    
    poolSize - amount of threads allocated for job execution
  - setThreadExecutor
```
public void setThreadExecutor(ThreadExecutor threadExecutor)
```
  - getThreadExecutor
```
public ThreadExecutor getThreadExecutor()
```
  - getInstanceName
```
public String getInstanceName()
```
    Get the instance name of the Scheduler (must be unique within this server instance).
  - getEstimatedTimeToReleaseAndAcquireTrigger
```
public long getEstimatedTimeToReleaseAndAcquireTrigger()
```
    Description copied from interface: JobStore
    
    How long (in milliseconds) the JobStore implementation estimates that it will take to release a trigger and acquire a new one.
    
    Specified by:
    
    getEstimatedTimeToReleaseAndAcquireTrigger in interface JobStore
  - setIsClustered
```
public void setIsClustered(boolean isClustered)
```
    Set whether this instance is part of a cluster.
  - isClustered
```
public boolean isClustered()
```
    Get whether this instance is part of a cluster.
    
    Specified by:
    
    isClustered in interface JobStore
  - getClusterCheckinInterval
```
public long getClusterCheckinInterval()
```
    Get the frequency (in milliseconds) at which this instance "checks-in" with the other instances of the cluster. -- Affects the rate of detecting failed instances.
  - setClusterCheckinInterval
```
public void setClusterCheckinInterval(long l)
```
    Set the frequency (in milliseconds) at which this instance "checks-in" with the other instances of the cluster. -- Affects the rate of detecting failed instances.
  - getMaxMisfiresToHandleAtATime
```
public int getMaxMisfiresToHandleAtATime()
```
    Get the maximum number of misfired triggers that the misfire handling thread will try to recover at one time (within one transaction). The default is 20.
  - setMaxMisfiresToHandleAtATime
```
public void setMaxMisfiresToHandleAtATime(int maxToRecoverAtATime)
```
    Set the maximum number of misfired triggers that the misfire handling thread will try to recover at one time (within one transaction). The default is 20.
  - getDbRetryInterval
```
public long getDbRetryInterval()
```
    Returns:
    
    Returns the dbRetryInterval.
  - setDbRetryInterval
```
public void setDbRetryInterval(long dbRetryInterval)
```
    Parameters:
    
    dbRetryInterval - The dbRetryInterval to set.
  - setUseDBLocks
```
public void setUseDBLocks(boolean useDBLocks)
```
    Set whether this instance should use database-based thread synchronization.
  - getUseDBLocks
```
public boolean getUseDBLocks()
```
    Get whether this instance should use database-based thread synchronization.
  - isLockOnInsert
```
public boolean isLockOnInsert()
```
  - setLockOnInsert
```
public void setLockOnInsert(boolean lockOnInsert)
```
    Whether or not to obtain locks when inserting new jobs/triggers.
    Defaults to true, which is safest. Some databases (such as MS SQLServer) seem to require this to avoid deadlocks under high load, while others seem to do fine without. Settings this to false means isolation guarantees between job scheduling and trigger acquisition are entirely enforced by the database. Depending on the database and it's configuration this may cause unusual scheduling behaviors.
    Setting this property to false will provide a significant performance increase during the addition of new jobs and triggers.
    
    Parameters:
    
    lockOnInsert - whether locking should be used when inserting new jobs/triggers
  - getMisfireThreshold
```
public long getMisfireThreshold()
```
  - setMisfireThreshold
```
public void setMisfireThreshold(long misfireThreshold)
```
    The the number of milliseconds by which a trigger must have missed its next-fire-time, in order for it to be considered "misfired" and thus have its misfire instruction applied.
    
    Parameters:
    
    misfireThreshold - the misfire threshold to use, in millis
  - isDontSetAutoCommitFalse
```
public boolean isDontSetAutoCommitFalse()
```
  - setDontSetAutoCommitFalse
```
public void setDontSetAutoCommitFalse(boolean b)
```
    Don't call set autocommit(false) on connections obtained from the DataSource. This can be helpful in a few situations, such as if you have a driver that complains if it is called when it is already off.
    
    Parameters:
    
    b - whether or not autocommit should be set to false on db connections
  - isTxIsolationLevelSerializable
```
public boolean isTxIsolationLevelSerializable()
```
  - setTxIsolationLevelSerializable
```
public void setTxIsolationLevelSerializable(boolean b)
```
    Set the transaction isolation level of DB connections to sequential.
    
    Parameters:
    
    b - whether isolation level should be set to sequential.
  - isAcquireTriggersWithinLock
```
public boolean isAcquireTriggersWithinLock()
```
    Whether or not the query and update to acquire a Trigger for firing should be performed after obtaining an explicit DB lock (to avoid possible race conditions on the trigger's db row). This is the behavior prior to Quartz 1.6.3, but is considered unnecessary for most databases (due to the nature of the SQL update that is performed), and therefore a superfluous performance hit.
  - setAcquireTriggersWithinLock
```
public void setAcquireTriggersWithinLock(boolean acquireTriggersWithinLock)
```
    Whether or not the query and update to acquire a Trigger for firing should be performed after obtaining an explicit DB lock. This is the behavior prior to Quartz 1.6.3, but is considered unnecessary for most databases, and therefore a superfluous performance hit. However, if batch acquisition is used, it is important for this behavior to be used for all dbs.
  - setDriverDelegateClass
```
public void setDriverDelegateClass(String delegateClassName)
                            throws InvalidConfigurationException
```
    Set the JDBC driver delegate class.
    
    Parameters:
    
    delegateClassName - the delegate class name
    
    Throws:
    
    InvalidConfigurationException
  - getDriverDelegateClass
```
public String getDriverDelegateClass()
```
    Get the JDBC driver delegate class name.
    
    Returns:
    
    the delegate class name
  - setDriverDelegateInitString
```
public void setDriverDelegateInitString(String delegateInitString)
                                 throws InvalidConfigurationException
```
    Set the JDBC driver delegate's initialization string.
    
    Parameters:
    
    delegateInitString - the delegate init string
    
    Throws:
    
    InvalidConfigurationException
  - getDriverDelegateInitString
```
public String getDriverDelegateInitString()
```
    Get the JDBC driver delegate's initialization string.
    
    Returns:
    
    the delegate init string
  - getSelectWithLockSQL
```
public String getSelectWithLockSQL()
```
  - setSelectWithLockSQL
```
public void setSelectWithLockSQL(String string)
```
    set the SQL statement to use to select and lock a row in the "locks" table.
    
    See Also:
    
    StdRowLockSemaphore
  - getClassLoadHelper
```
protected ClassLoadHelper getClassLoadHelper()
```
  - getMakeThreadsDaemons
```
public boolean getMakeThreadsDaemons()
```
    Get whether the threads spawned by this JobStore should be marked as daemon. Possible threads include the MisfireHandler and the ClusterManager.
    
    See Also:
    
    Thread.setDaemon(boolean)
  - setMakeThreadsDaemons
```
public void setMakeThreadsDaemons(boolean makeThreadsDaemons)
```
    Set whether the threads spawned by this JobStore should be marked as daemon. Possible threads include the MisfireHandler and the ClusterManager.
    
    See Also:
    
    Thread.setDaemon(boolean)
  - isThreadsInheritInitializersClassLoadContext
```
public boolean isThreadsInheritInitializersClassLoadContext()
```
    Get whether to set the class load context of spawned threads to that of the initializing thread.
  - setThreadsInheritInitializersClassLoadContext
```
public void setThreadsInheritInitializersClassLoadContext(boolean threadsInheritInitializersClassLoadContext)
```
    Set whether to set the class load context of spawned threads to that of the initializing thread.
  - getDoubleCheckLockMisfireHandler
```
public boolean getDoubleCheckLockMisfireHandler()
```
    Get whether to check to see if there are Triggers that have misfired before actually acquiring the lock to recover them. This should be set to false if the majority of the time, there are are misfired Triggers.
  - setDoubleCheckLockMisfireHandler
```
public void setDoubleCheckLockMisfireHandler(boolean doubleCheckLockMisfireHandler)
```
    Set whether to check to see if there are Triggers that have misfired before actually acquiring the lock to recover them. This should be set to false if the majority of the time, there are are misfired Triggers.
  - getAcquireRetryDelay
```
public long getAcquireRetryDelay(int failureCount)
```
    Description copied from interface: JobStore
    
    Get the amount of time (in ms) to wait when accessing this job store repeatedly fails. Called by the executor thread(s) when calls to JobStore.acquireNextTriggers(long, int, long) fail more than once in succession, and the thread thus wants to wait a bit before trying again, to not consume 100% CPU, write huge amounts of errors into logs, etc. in cases like the DB being offline/restarting. The delay returned by implementations should be between 20 and 600000 milliseconds.
    
    Specified by:
    
    getAcquireRetryDelay in interface JobStore
    
    Parameters:
    
    failureCount - the number of successive failures seen so far
    
    Returns:
    
    the time (in milliseconds) to wait before trying again
  - getLog
```
protected org.slf4j.Logger getLog()
```
  - initialize
```
public void initialize(ClassLoadHelper loadHelper,
                       SchedulerSignaler signaler)
                throws SchedulerConfigException
```
    Called by the QuartzScheduler before the JobStore is used, in order to give it a chance to initialize.
    
    Specified by:
    
    initialize in interface JobStore
    
    Throws:
    
    SchedulerConfigException
  - schedulerStarted
```
public void schedulerStarted()
                      throws SchedulerException
```
    Description copied from interface: JobStore
    
    Called by the QuartzScheduler to inform the JobStore that the scheduler has started.
    
    Specified by:
    
    schedulerStarted in interface JobStore
    
    Throws:
    
    SchedulerException
    
    See Also:
    
    JobStore.schedulerStarted()
  - schedulerPaused
```
public void schedulerPaused()
```
    Description copied from interface: JobStore
    
    Called by the QuartzScheduler to inform the JobStore that the scheduler has been paused.
    
    Specified by:
    
    schedulerPaused in interface JobStore
  - schedulerResumed
```
public void schedulerResumed()
```
    Description copied from interface: JobStore
    
    Called by the QuartzScheduler to inform the JobStore that the scheduler has resumed after being paused.
    
    Specified by:
    
    schedulerResumed in interface JobStore
  - shutdown
```
public void shutdown()
```
    Called by the QuartzScheduler to inform the JobStore that it should free up all of it's resources because the scheduler is shutting down.
    
    Specified by:
    
    shutdown in interface JobStore
  - supportsPersistence
```
public boolean supportsPersistence()
```
    Specified by:
    
    supportsPersistence in interface JobStore
  - getNonManagedTXConnection
```
protected abstract Connection getNonManagedTXConnection()
                                                 throws JobPersistenceException
```
    Throws:
    
    JobPersistenceException
  - getAttributeRestoringConnection
```
protected Connection getAttributeRestoringConnection(Connection conn)
```
    Wrap the given Connection in a Proxy such that attributes that might be set will be restored before the connection is closed (and potentially restored to a pool).
  - getConnection
```
protected Connection getConnection()
                            throws JobPersistenceException
```
    Throws:
    
    JobPersistenceException
  - releaseLock
```
protected void releaseLock(String lockName,
                           boolean doIt)
```
  - recoverJobs
```
protected void recoverJobs()
                    throws JobPersistenceException
```
    Recover any failed or misfired jobs and clean up the data store as appropriate.
    
    Throws:
    
    JobPersistenceException - if jobs could not be recovered
  - recoverJobs
```
protected void recoverJobs(Connection conn)
                    throws JobPersistenceException
```
    Will recover any failed or misfired jobs and clean up the data store as appropriate.
    
    Throws:
    
    JobPersistenceException - if jobs could not be recovered
  - getMisfireTime
```
protected long getMisfireTime()
```
  - recoverMisfiredJobs
```
protected JobStoreSupport.RecoverMisfiredJobsResult recoverMisfiredJobs(Connection conn,
                                                                        boolean recovering)
                                                                 throws JobPersistenceException,
                                                                        SQLException
```
    Throws:
    
    JobPersistenceException
    
    SQLException
  - updateMisfiredTrigger
```
protected boolean updateMisfiredTrigger(Connection conn,
                                        TriggerKey triggerKey,
                                        String newStateIfNotComplete,
                                        boolean forceState)
                                 throws JobPersistenceException
```
    Throws:
    
    JobPersistenceException
  - storeJobAndTrigger
```
public void storeJobAndTrigger(JobDetail newJob,
                               OperableTrigger newTrigger)
                        throws JobPersistenceException
```
    Store the given JobDetail and Trigger.
    
    Specified by:
    
    storeJobAndTrigger in interface JobStore
    
    Parameters:
    
    newJob - The JobDetail to be stored.
    
    newTrigger - The Trigger to be stored.
    
    Throws:
    
    ObjectAlreadyExistsException - if a Job with the same name/group already exists.
    
    JobPersistenceException
  - storeJob
```
public void storeJob(JobDetail newJob,
                     boolean replaceExisting)
              throws JobPersistenceException
```
    Store the given JobDetail.
    
    Specified by:
    
    storeJob in interface JobStore
    
    Parameters:
    
    newJob - The JobDetail to be stored.
    
    replaceExisting - If true, any Job existing in the JobStore with the same name & group should be over-written.
    
    Throws:
    
    ObjectAlreadyExistsException - if a Job with the same name/group already exists, and replaceExisting is set to false.
    
    JobPersistenceException
  - storeJob
```
protected void storeJob(Connection conn,
                        JobDetail newJob,
                        boolean replaceExisting)
                 throws JobPersistenceException
```
    Insert or update a job.
    
    Throws:
    
    JobPersistenceException
  - jobExists
```
protected boolean jobExists(Connection conn,
                            JobKey jobKey)
                     throws JobPersistenceException
```
    Check existence of a given job.
    
    Throws:
    
    JobPersistenceException
  - storeTrigger
```
public void storeTrigger(OperableTrigger newTrigger,
                         boolean replaceExisting)
                  throws JobPersistenceException
```
    Store the given Trigger.
    
    Specified by:
    
    storeTrigger in interface JobStore
    
    Parameters:
    
    newTrigger - The Trigger to be stored.
    
    replaceExisting - If true, any Trigger existing in the JobStore with the same name & group should be over-written.
    
    Throws:
    
    ObjectAlreadyExistsException - if a Trigger with the same name/group already exists, and replaceExisting is set to false.
    
    JobPersistenceException
    
    See Also:
    
    JobStore.pauseTriggers(org.quartz.impl.matchers.GroupMatcher)
  - storeTrigger
```
protected void storeTrigger(Connection conn,
                            OperableTrigger newTrigger,
                            JobDetail job,
                            boolean replaceExisting,
                            String state,
                            boolean forceState,
                            boolean recovering)
                     throws JobPersistenceException
```
    Insert or update a trigger.
    
    Throws:
    
    JobPersistenceException
  - triggerExists
```
protected boolean triggerExists(Connection conn,
                                TriggerKey key)
                         throws JobPersistenceException
```
    Check existence of a given trigger.
    
    Throws:
    
    JobPersistenceException
  - removeJob
```
public boolean removeJob(JobKey jobKey)
                  throws JobPersistenceException
```
    Remove (delete) the Job with the given name, and any Trigger s that reference it.
    
    If removal of the Job results in an empty group, the group should be removed from the JobStore's list of known group names.
    
    Specified by:
    
    removeJob in interface JobStore
    
    Returns:
    
    true if a Job with the given name & group was found and removed from the store.
    
    Throws:
    
    JobPersistenceException
  - removeJob
```
protected boolean removeJob(Connection conn,
                            JobKey jobKey)
                     throws JobPersistenceException
```
    Throws:
    
    JobPersistenceException
  - removeJobs
```
public boolean removeJobs(List<JobKey> jobKeys)
                   throws JobPersistenceException
```
    Specified by:
    
    removeJobs in interface JobStore
    
    Throws:
    
    JobPersistenceException
  - removeTriggers
```
public boolean removeTriggers(List<TriggerKey> triggerKeys)
                       throws JobPersistenceException
```
    Specified by:
    
    removeTriggers in interface JobStore
    
    Throws:
    
    JobPersistenceException
  - storeJobsAndTriggers
```
public void storeJobsAndTriggers(Map<JobDetail,Set<? extends Trigger>> triggersAndJobs,
                                 boolean replace)
                          throws JobPersistenceException
```
    Specified by:
    
    storeJobsAndTriggers in interface JobStore
    
    Throws:
    
    JobPersistenceException
  - retrieveJob
```
public JobDetail retrieveJob(JobKey jobKey)
                      throws JobPersistenceException
```
    Retrieve the JobDetail for the given Job.
    
    Specified by:
    
    retrieveJob in interface JobStore
    
    Returns:
    
    The desired Job, or null if there is no match.
    
    Throws:
    
    JobPersistenceException
  - retrieveJob
```
protected JobDetail retrieveJob(Connection conn,
                                JobKey key)
                         throws JobPersistenceException
```
    Throws:
    
    JobPersistenceException
  - removeTrigger
```
public boolean removeTrigger(TriggerKey triggerKey)
                      throws JobPersistenceException
```
    Remove (delete) the Trigger with the given name.
    
    If removal of the Trigger results in an empty group, the group should be removed from the JobStore's list of known group names.
    
    If removal of the Trigger results in an 'orphaned' Job that is not 'durable', then the Job should be deleted also.
    
    Specified by:
    
    removeTrigger in interface JobStore
    
    Returns:
    
    true if a Trigger with the given name & group was found and removed from the store.
    
    Throws:
    
    JobPersistenceException
  - removeTrigger
```
protected boolean removeTrigger(Connection conn,
                                TriggerKey key)
                         throws JobPersistenceException
```
    Throws:
    
    JobPersistenceException
  - replaceTrigger
```
public boolean replaceTrigger(TriggerKey triggerKey,
                              OperableTrigger newTrigger)
                       throws JobPersistenceException
```
    Description copied from interface: JobStore
    
    Remove (delete) the Trigger with the given key, and store the new given one - which must be associated with the same job.
    
    Specified by:
    
    replaceTrigger in interface JobStore
    
    newTrigger - The new Trigger to be stored.
    
    Returns:
    
    true if a Trigger with the given name & group was found and removed from the store.
    
    Throws:
    
    JobPersistenceException
    
    See Also:
    
    JobStore.replaceTrigger(TriggerKey, OperableTrigger)
  - replaceTrigger
```
protected boolean replaceTrigger(Connection conn,
                                 TriggerKey key,
                                 OperableTrigger newTrigger)
                          throws JobPersistenceException
```
    Throws:
    
    JobPersistenceException
  - retrieveTrigger
```
public OperableTrigger retrieveTrigger(TriggerKey triggerKey)
                                throws JobPersistenceException
```
    Retrieve the given Trigger.
    
    Specified by:
    
    retrieveTrigger in interface JobStore
    
    Returns:
    
    The desired Trigger, or null if there is no match.
    
    Throws:
    
    JobPersistenceException
  - retrieveTrigger
```
protected OperableTrigger retrieveTrigger(Connection conn,
                                          TriggerKey key)
                                   throws JobPersistenceException
```
    Throws:
    
    JobPersistenceException
  - getTriggerState
```
public Trigger.TriggerState getTriggerState(TriggerKey triggerKey)
                                     throws JobPersistenceException
```
    Get the current state of the identified Trigger.
    
    Specified by:
    
    getTriggerState in interface JobStore
    
    Throws:
    
    JobPersistenceException
    
    See Also:
    
    Trigger.TriggerState.NORMAL, Trigger.TriggerState.PAUSED, Trigger.TriggerState.COMPLETE, Trigger.TriggerState.ERROR, Trigger.TriggerState.NONE
  - getTriggerState
```
public Trigger.TriggerState getTriggerState(Connection conn,
                                            TriggerKey key)
                                     throws JobPersistenceException
```
    Throws:
    
    JobPersistenceException
  - resetTriggerFromErrorState
```
public void resetTriggerFromErrorState(TriggerKey triggerKey)
                                throws JobPersistenceException
```
    Reset the current state of the identified Trigger from Trigger.TriggerState.ERROR to Trigger.TriggerState.NORMAL or Trigger.TriggerState.PAUSED as appropriate.
    Only affects triggers that are in ERROR state - if identified trigger is not in that state then the result is a no-op.
    
    The result will be the trigger returning to the normal, waiting to be fired state, unless the trigger's group has been paused, in which case it will go into the PAUSED state.
    
    Specified by:
    
    resetTriggerFromErrorState in interface JobStore
    
    Throws:
    
    JobPersistenceException
  - storeCalendar
```
public void storeCalendar(String calName,
                          Calendar calendar,
                          boolean replaceExisting,
                          boolean updateTriggers)
                   throws JobPersistenceException
```
    Store the given Calendar.
    
    Specified by:
    
    storeCalendar in interface JobStore
    
    Parameters:
    
    calName - The name of the calendar.
    
    calendar - The Calendar to be stored.
    
    replaceExisting - If true, any Calendar existing in the JobStore with the same name & group should be over-written.
    
    updateTriggers - If true, any Triggers existing in the JobStore that reference an existing Calendar with the same name with have their next fire time re-computed with the new Calendar.
    
    Throws:
    
    ObjectAlreadyExistsException - if a Calendar with the same name already exists, and replaceExisting is set to false.
    
    JobPersistenceException
  - storeCalendar
```
protected void storeCalendar(Connection conn,
                             String calName,
                             Calendar calendar,
                             boolean replaceExisting,
                             boolean updateTriggers)
                      throws JobPersistenceException
```
    Throws:
    
    JobPersistenceException
  - calendarExists
```
protected boolean calendarExists(Connection conn,
                                 String calName)
                          throws JobPersistenceException
```
    Throws:
    
    JobPersistenceException
  - removeCalendar
```
public boolean removeCalendar(String calName)
                       throws JobPersistenceException
```
    Remove (delete) the Calendar with the given name.
    
    If removal of the Calendar would result in Triggers pointing to non-existent calendars, then a JobPersistenceException will be thrown.
    *
    
    Specified by:
    
    removeCalendar in interface JobStore
    
    Parameters:
    
    calName - The name of the Calendar to be removed.
    
    Returns:
    
    true if a Calendar with the given name was found and removed from the store.
    
    Throws:
    
    JobPersistenceException
  - removeCalendar
```
protected boolean removeCalendar(Connection conn,
                                 String calName)
                          throws JobPersistenceException
```
    Throws:
    
    JobPersistenceException
  - retrieveCalendar
```
public Calendar retrieveCalendar(String calName)
                          throws JobPersistenceException
```
    Retrieve the given Trigger.
    
    Specified by:
    
    retrieveCalendar in interface JobStore
    
    Parameters:
    
    calName - The name of the Calendar to be retrieved.
    
    Returns:
    
    The desired Calendar, or null if there is no match.
    
    Throws:
    
    JobPersistenceException
  - retrieveCalendar
```
protected Calendar retrieveCalendar(Connection conn,
                                    String calName)
                             throws JobPersistenceException
```
    Throws:
    
    JobPersistenceException
  - getNumberOfJobs
```
public int getNumberOfJobs()
                    throws JobPersistenceException
```
    Get the number of Job s that are stored in the JobStore.
    
    Specified by:
    
    getNumberOfJobs in interface JobStore
    
    Throws:
    
    JobPersistenceException
  - getNumberOfJobs
```
protected int getNumberOfJobs(Connection conn)
                       throws JobPersistenceException
```
    Throws:
    
    JobPersistenceException
  - getNumberOfTriggers
```
public int getNumberOfTriggers()
                        throws JobPersistenceException
```
    Get the number of Trigger s that are stored in the JobsStore.
    
    Specified by:
    
    getNumberOfTriggers in interface JobStore
    
    Throws:
    
    JobPersistenceException
  - getNumberOfTriggers
```
protected int getNumberOfTriggers(Connection conn)
                           throws JobPersistenceException
```
    Throws:
    
    JobPersistenceException
  - getNumberOfCalendars
```
public int getNumberOfCalendars()
                         throws JobPersistenceException
```
    Get the number of Calendar s that are stored in the JobsStore.
    
    Specified by:
    
    getNumberOfCalendars in interface JobStore
    
    Throws:
    
    JobPersistenceException
  - getNumberOfCalendars
```
protected int getNumberOfCalendars(Connection conn)
                            throws JobPersistenceException
```
    Throws:
    
    JobPersistenceException
  - getJobKeys
```
public Set<JobKey> getJobKeys(GroupMatcher<JobKey> matcher)
                       throws JobPersistenceException
```
    Get the names of all of the Job s that matcher the given groupMatcher.
    
    If there are no jobs in the given group name, the result should be an empty Set
    
    Specified by:
    
    getJobKeys in interface JobStore
    
    Throws:
    
    JobPersistenceException
  - getJobNames
```
protected Set<JobKey> getJobNames(Connection conn,
                                  GroupMatcher<JobKey> matcher)
                           throws JobPersistenceException
```
    Throws:
    
    JobPersistenceException
  - checkExists
```
public boolean checkExists(JobKey jobKey)
                    throws JobPersistenceException
```
    Determine whether a Job with the given identifier already exists within the scheduler.
    
    Specified by:
    
    checkExists in interface JobStore
    
    Parameters:
    
    jobKey - the identifier to check for
    
    Returns:
    
    true if a Job exists with the given identifier
    
    Throws:
    
    JobPersistenceException
  - checkExists
```
protected boolean checkExists(Connection conn,
                              JobKey jobKey)
                       throws JobPersistenceException
```
    Throws:
    
    JobPersistenceException
  - checkExists
```
public boolean checkExists(TriggerKey triggerKey)
                    throws JobPersistenceException
```
    Determine whether a Trigger with the given identifier already exists within the scheduler.
    
    Specified by:
    
    checkExists in interface JobStore
    
    Parameters:
    
    triggerKey - the identifier to check for
    
    Returns:
    
    true if a Trigger exists with the given identifier
    
    Throws:
    
    JobPersistenceException
  - checkExists
```
protected boolean checkExists(Connection conn,
                              TriggerKey triggerKey)
                       throws JobPersistenceException
```
    Throws:
    
    JobPersistenceException
  - clearAllSchedulingData
```
public void clearAllSchedulingData()
                            throws JobPersistenceException
```
    Clear (delete!) all scheduling data - all Jobs, Triggers Calendars.
    
    Specified by:
    
    clearAllSchedulingData in interface JobStore
    
    Throws:
    
    JobPersistenceException
  - clearAllSchedulingData
```
protected void clearAllSchedulingData(Connection conn)
                               throws JobPersistenceException
```
    Throws:
    
    JobPersistenceException
  - getTriggerKeys
```
public Set<TriggerKey> getTriggerKeys(GroupMatcher<TriggerKey> matcher)
                               throws JobPersistenceException
```
    Get the names of all of the Trigger s that match the given group Matcher.
    
    If there are no triggers in the given group name, the result should be a an empty Set (not null).
    
    Specified by:
    
    getTriggerKeys in interface JobStore
    
    Throws:
    
    JobPersistenceException
  - getTriggerNames
```
protected Set<TriggerKey> getTriggerNames(Connection conn,
                                          GroupMatcher<TriggerKey> matcher)
                                   throws JobPersistenceException
```
    Throws:
    
    JobPersistenceException
  - getJobGroupNames
```
public List<String> getJobGroupNames()
                              throws JobPersistenceException
```
    Get the names of all of the Job groups.
    
    If there are no known group names, the result should be a zero-length array (not null).
    
    Specified by:
    
    getJobGroupNames in interface JobStore
    
    Throws:
    
    JobPersistenceException
  - getJobGroupNames
```
protected List<String> getJobGroupNames(Connection conn)
                                 throws JobPersistenceException
```
    Throws:
    
    JobPersistenceException
  - getTriggerGroupNames
```
public List<String> getTriggerGroupNames()
                                  throws JobPersistenceException
```
    Get the names of all of the Trigger groups.
    
    If there are no known group names, the result should be a zero-length array (not null).
    
    Specified by:
    
    getTriggerGroupNames in interface JobStore
    
    Throws:
    
    JobPersistenceException
  - getTriggerGroupNames
```
protected List<String> getTriggerGroupNames(Connection conn)
                                     throws JobPersistenceException
```
    Throws:
    
    JobPersistenceException
  - getCalendarNames
```
public List<String> getCalendarNames()
                              throws JobPersistenceException
```
    Get the names of all of the Calendar s in the JobStore.
    
    If there are no Calendars in the given group name, the result should be a zero-length array (not null).
    
    Specified by:
    
    getCalendarNames in interface JobStore
    
    Throws:
    
    JobPersistenceException
  - getCalendarNames
```
protected List<String> getCalendarNames(Connection conn)
                                 throws JobPersistenceException
```
    Throws:
    
    JobPersistenceException
  - getTriggersForJob
```
public List<OperableTrigger> getTriggersForJob(JobKey jobKey)
                                        throws JobPersistenceException
```
    Get all of the Triggers that are associated to the given Job.
    
    If there are no matches, a zero-length array should be returned.
    
    Specified by:
    
    getTriggersForJob in interface JobStore
    
    Throws:
    
    JobPersistenceException
  - getTriggersForJob
```
protected List<OperableTrigger> getTriggersForJob(Connection conn,
                                                  JobKey key)
                                           throws JobPersistenceException
```
    Throws:
    
    JobPersistenceException
  - pauseTrigger
```
public void pauseTrigger(TriggerKey triggerKey)
                  throws JobPersistenceException
```
    Pause the Trigger with the given name.
    
    Specified by:
    
    pauseTrigger in interface JobStore
    
    Throws:
    
    JobPersistenceException
    
    See Also:
    
    resumeTrigger(TriggerKey)
  - pauseTrigger
```
public void pauseTrigger(Connection conn,
                         TriggerKey triggerKey)
                  throws JobPersistenceException
```
    Pause the Trigger with the given name.
    
    Throws:
    
    JobPersistenceException
    
    See Also:
    
    resumeTrigger(Connection, TriggerKey)
  - pauseJob
```
public void pauseJob(JobKey jobKey)
              throws JobPersistenceException
```
    Pause the Job with the given name - by pausing all of its current Triggers.
    
    Specified by:
    
    pauseJob in interface JobStore
    
    Throws:
    
    JobPersistenceException
    
    See Also:
    
    resumeJob(JobKey)
  - pauseJobs
```
public Set<String> pauseJobs(GroupMatcher<JobKey> matcher)
                      throws JobPersistenceException
```
    Pause all of the Jobs matching the given groupMatcher - by pausing all of their Triggers.
    
    Specified by:
    
    pauseJobs in interface JobStore
    
    Throws:
    
    JobPersistenceException
    
    See Also:
    
    resumeJobs(org.quartz.impl.matchers.GroupMatcher)
  - checkBlockedState
```
protected String checkBlockedState(Connection conn,
                                   JobKey jobKey,
                                   String currentState)
                            throws JobPersistenceException
```
    Determines if a Trigger for the given job should be blocked. State can only transition to STATE_PAUSED_BLOCKED/BLOCKED from PAUSED/STATE_WAITING respectively.
    
    Returns:
    
    STATE_PAUSED_BLOCKED, BLOCKED, or the currentState.
    
    Throws:
    
    JobPersistenceException
  - resumeTrigger
```
public void resumeTrigger(TriggerKey triggerKey)
                   throws JobPersistenceException
```
    Resume (un-pause) the Trigger with the given name.
    
    If the Trigger missed one or more fire-times, then the Trigger's misfire instruction will be applied.
    
    Specified by:
    
    resumeTrigger in interface JobStore
    
    Throws:
    
    JobPersistenceException
    
    See Also:
    
    pauseTrigger(TriggerKey)
  - resumeTrigger
```
public void resumeTrigger(Connection conn,
                          TriggerKey key)
                   throws JobPersistenceException
```
    Resume (un-pause) the Trigger with the given name.
    
    If the Trigger missed one or more fire-times, then the Trigger's misfire instruction will be applied.
    
    Throws:
    
    JobPersistenceException
    
    See Also:
    
    pauseTrigger(Connection, TriggerKey)
  - resumeJob
```
public void resumeJob(JobKey jobKey)
               throws JobPersistenceException
```
    Resume (un-pause) the Job with the given name.
    
    If any of the Job'sTrigger s missed one or more fire-times, then the Trigger's misfire instruction will be applied.
    
    Specified by:
    
    resumeJob in interface JobStore
    
    Throws:
    
    JobPersistenceException
    
    See Also:
    
    pauseJob(JobKey)
  - resumeJobs
```
public Set<String> resumeJobs(GroupMatcher<JobKey> matcher)
                       throws JobPersistenceException
```
    Resume (un-pause) all of the Jobs in the given group.
    
    If any of the Job s had Trigger s that missed one or more fire-times, then the Trigger's misfire instruction will be applied.
    
    Specified by:
    
    resumeJobs in interface JobStore
    
    Throws:
    
    JobPersistenceException
    
    See Also:
    
    pauseJobs(org.quartz.impl.matchers.GroupMatcher)
  - pauseTriggers
```
public Set<String> pauseTriggers(GroupMatcher<TriggerKey> matcher)
                          throws JobPersistenceException
```
    Pause all of the Triggers matching the given groupMatcher.
    
    Specified by:
    
    pauseTriggers in interface JobStore
    
    Throws:
    
    JobPersistenceException
    
    See Also:
    
    resumeTriggerGroup(java.sql.Connection, org.quartz.impl.matchers.GroupMatcher)
  - pauseTriggerGroup
```
public Set<String> pauseTriggerGroup(Connection conn,
                                     GroupMatcher<TriggerKey> matcher)
                              throws JobPersistenceException
```
    Pause all of the Triggers matching the given groupMatcher.
    
    Throws:
    
    JobPersistenceException
    
    See Also:
    
    resumeTriggerGroup(java.sql.Connection, org.quartz.impl.matchers.GroupMatcher)
  - getPausedTriggerGroups
```
public Set<String> getPausedTriggerGroups()
                                   throws JobPersistenceException
```
    Specified by:
    
    getPausedTriggerGroups in interface JobStore
    
    Throws:
    
    JobPersistenceException
  - getPausedTriggerGroups
```
public Set<String> getPausedTriggerGroups(Connection conn)
                                   throws JobPersistenceException
```
    Pause all of the Triggers in the given group.
    
    Throws:
    
    JobPersistenceException
    
    See Also:
    
    resumeTriggers(org.quartz.impl.matchers.GroupMatcher)
  - resumeTriggers
```
public Set<String> resumeTriggers(GroupMatcher<TriggerKey> matcher)
                           throws JobPersistenceException
```
    Resume (un-pause) all of the Triggers matching the given groupMatcher.
    
    If any Trigger missed one or more fire-times, then the Trigger's misfire instruction will be applied.
    
    Specified by:
    
    resumeTriggers in interface JobStore
    
    Throws:
    
    JobPersistenceException
    
    See Also:
    
    pauseTriggers(org.quartz.impl.matchers.GroupMatcher)
  - resumeTriggerGroup
```
public Set<String> resumeTriggerGroup(Connection conn,
                                      GroupMatcher<TriggerKey> matcher)
                               throws JobPersistenceException
```
    Resume (un-pause) all of the Triggers matching the given groupMatcher.
    
    If any Trigger missed one or more fire-times, then the Trigger's misfire instruction will be applied.
    
    Throws:
    
    JobPersistenceException
    
    See Also:
    
    pauseTriggers(org.quartz.impl.matchers.GroupMatcher)
  - pauseAll
```
public void pauseAll()
              throws JobPersistenceException
```
    Pause all triggers - equivalent of calling pauseTriggerGroup(group) on every group.
    
    When resumeAll() is called (to un-pause), trigger misfire instructions WILL be applied.
    
    Specified by:
    
    pauseAll in interface JobStore
    
    Throws:
    
    JobPersistenceException
    
    See Also:
    
    resumeAll(), pauseTriggerGroup(java.sql.Connection, org.quartz.impl.matchers.GroupMatcher)
  - pauseAll
```
public void pauseAll(Connection conn)
              throws JobPersistenceException
```
    Pause all triggers - equivalent of calling pauseTriggerGroup(group) on every group.
    
    When resumeAll() is called (to un-pause), trigger misfire instructions WILL be applied.
    
    Throws:
    
    JobPersistenceException
    
    See Also:
    
    resumeAll(Connection), pauseTriggerGroup(java.sql.Connection, org.quartz.impl.matchers.GroupMatcher)
  - resumeAll
```
public void resumeAll()
               throws JobPersistenceException
```
    Resume (un-pause) all triggers - equivalent of calling resumeTriggerGroup(group) on every group.
    
    If any Trigger missed one or more fire-times, then the Trigger's misfire instruction will be applied.
    
    Specified by:
    
    resumeAll in interface JobStore
    
    Throws:
    
    JobPersistenceException
    
    See Also:
    
    pauseAll()
  - resumeAll
```
public void resumeAll(Connection conn)
               throws JobPersistenceException
```
    protected
    Resume (un-pause) all triggers - equivalent of calling resumeTriggerGroup(group) on every group.
    
    If any Trigger missed one or more fire-times, then the Trigger's misfire instruction will be applied.
    
    Throws:
    
    JobPersistenceException
    
    See Also:
    
    pauseAll(Connection)
  - getFiredTriggerRecordId
```
protected String getFiredTriggerRecordId()
```
  - acquireNextTriggers
```
public List<OperableTrigger> acquireNextTriggers(long noLaterThan,
                                                 int maxCount,
                                                 long timeWindow)
                                          throws JobPersistenceException
```
    Get a handle to the next N triggers to be fired, and mark them as 'reserved' by the calling scheduler.
    
    Specified by:
    
    acquireNextTriggers in interface JobStore
    
    Parameters:
    
    noLaterThan - If > 0, the JobStore should only return a Trigger that will fire no later than the time represented in this value as milliseconds.
    
    Throws:
    
    JobPersistenceException
    
    See Also:
    
    releaseAcquiredTrigger(OperableTrigger)
  - acquireNextTrigger
```
protected List<OperableTrigger> acquireNextTrigger(Connection conn,
                                                   long noLaterThan,
                                                   int maxCount,
                                                   long timeWindow)
                                            throws JobPersistenceException
```
    Throws:
    
    JobPersistenceException
  - releaseAcquiredTrigger
```
public void releaseAcquiredTrigger(OperableTrigger trigger)
```
    Inform the JobStore that the scheduler no longer plans to fire the given Trigger, that it had previously acquired (reserved).
    
    Specified by:
    
    releaseAcquiredTrigger in interface JobStore
  - releaseAcquiredTrigger
```
protected void releaseAcquiredTrigger(Connection conn,
                                      OperableTrigger trigger)
                               throws JobPersistenceException
```
    Throws:
    
    JobPersistenceException
  - triggersFired
```
public List<TriggerFiredResult> triggersFired(List<OperableTrigger> triggers)
                                       throws JobPersistenceException
```
    Inform the JobStore that the scheduler is now firing the given Trigger (executing its associated Job), that it had previously acquired (reserved).
    
    Specified by:
    
    triggersFired in interface JobStore
    
    Returns:
    
    null if the trigger or its job or calendar no longer exist, or if the trigger was not successfully put into the 'executing' state.
    
    Throws:
    
    JobPersistenceException
  - triggerFired
```
protected TriggerFiredBundle triggerFired(Connection conn,
                                          OperableTrigger trigger)
                                   throws JobPersistenceException
```
    Throws:
    
    JobPersistenceException
  - triggeredJobComplete
```
public void triggeredJobComplete(OperableTrigger trigger,
                                 JobDetail jobDetail,
                                 Trigger.CompletedExecutionInstruction triggerInstCode)
```
    Inform the JobStore that the scheduler has completed the firing of the given Trigger (and the execution its associated Job), and that the JobDataMap in the given JobDetail should be updated if the Job is stateful.
    
    Specified by:
    
    triggeredJobComplete in interface JobStore
  - triggeredJobComplete
```
protected void triggeredJobComplete(Connection conn,
                                    OperableTrigger trigger,
                                    JobDetail jobDetail,
                                    Trigger.CompletedExecutionInstruction triggerInstCode)
                             throws JobPersistenceException
```
    Throws:
    
    JobPersistenceException
  - getDelegate
```
protected DriverDelegate getDelegate()
                              throws NoSuchDelegateException
```
    Get the driver delegate for DB operations.
    
    Throws:
    
    NoSuchDelegateException
  - getLockHandler
```
protected Semaphore getLockHandler()
```
  - setLockHandler
```
public void setLockHandler(Semaphore lockHandler)
```
  - doRecoverMisfires
```
protected JobStoreSupport.RecoverMisfiredJobsResult doRecoverMisfires()
                                                               throws JobPersistenceException
```
    Throws:
    
    JobPersistenceException
  - signalSchedulingChangeOnTxCompletion
```
protected void signalSchedulingChangeOnTxCompletion(long candidateNewNextFireTime)
```
  - clearAndGetSignalSchedulingChangeOnTxCompletion
```
protected Long clearAndGetSignalSchedulingChangeOnTxCompletion()
```
  - signalSchedulingChangeImmediately
```
protected void signalSchedulingChangeImmediately(long candidateNewNextFireTime)
```
  - doCheckin
```
protected boolean doCheckin()
                     throws JobPersistenceException
```
    Throws:
    
    JobPersistenceException
  - findFailedInstances
```
protected List<SchedulerStateRecord> findFailedInstances(Connection conn)
                                                  throws JobPersistenceException
```
    Get a list of all scheduler instances in the cluster that may have failed. This includes this scheduler if it is checking in for the first time.
    
    Throws:
    
    JobPersistenceException
  - calcFailedIfAfter
```
protected long calcFailedIfAfter(SchedulerStateRecord rec)
```
  - clusterCheckIn
```
protected List<SchedulerStateRecord> clusterCheckIn(Connection conn)
                                             throws JobPersistenceException
```
    Throws:
    
    JobPersistenceException
  - clusterRecover
```
protected void clusterRecover(Connection conn,
                              List<SchedulerStateRecord> failedInstances)
                       throws JobPersistenceException
```
    Throws:
    
    JobPersistenceException
  - logWarnIfNonZero
```
protected void logWarnIfNonZero(int val,
                                String warning)
```
  - cleanupConnection
```
protected void cleanupConnection(Connection conn)
```
    Cleanup the given database connection. This means restoring any modified auto commit or transaction isolation connection attributes, and then closing the underlying connection.
    
    This is separate from closeConnection() because the Spring integration relies on being able to overload closeConnection() and expects the same connection back that it originally returned from the datasource.
    
    See Also:
    
    closeConnection(Connection)
  - closeConnection
```
protected void closeConnection(Connection conn)
```
    Closes the supplied Connection.
    Ignores a null Connection. Any exception thrown trying to close the Connection is logged and ignored.
    
    Parameters:
    
    conn - The Connection to close (Optional).
  - rollbackConnection
```
protected void rollbackConnection(Connection conn)
```
    Rollback the supplied connection.
    Logs any SQLException it gets trying to rollback, but will not propogate the exception lest it mask the exception that caused the caller to need to rollback in the first place.
    
    Parameters:
    
    conn - (Optional)
  - commitConnection
```
protected void commitConnection(Connection conn)
                         throws JobPersistenceException
```
    Commit the supplied connection
    
    Parameters:
    
    conn - (Optional)
    
    Throws:
    
    JobPersistenceException - thrown if a SQLException occurs when the connection is committed
  - executeWithoutLock
```
public <T> T executeWithoutLock(JobStoreSupport.TransactionCallback<T> txCallback)
                         throws JobPersistenceException
```
    Execute the given callback in a transaction. Depending on the JobStore, the surrounding transaction may be assumed to be already present (managed).
    This method just forwards to executeInLock() with a null lockName.
    
    Throws:
    
    JobPersistenceException
    
    See Also:
    
    executeInLock(String, TransactionCallback)
  - executeInLock
```
protected abstract <T> T executeInLock(String lockName,
                                       JobStoreSupport.TransactionCallback<T> txCallback)
                                throws JobPersistenceException
```
    Execute the given callback having acquired the given lock. Depending on the JobStore, the surrounding transaction may be assumed to be already present (managed).
    
    Parameters:
    
    lockName - The name of the lock to acquire, for example "TRIGGER_ACCESS". If null, then no lock is acquired, but the lockCallback is still executed in a transaction.
    
    Throws:
    
    JobPersistenceException
  - retryExecuteInNonManagedTXLock
```
protected <T> T retryExecuteInNonManagedTXLock(String lockName,
                                               JobStoreSupport.TransactionCallback<T> txCallback)
```
  - executeInNonManagedTXLock
```
protected <T> T executeInNonManagedTXLock(String lockName,
                                          JobStoreSupport.TransactionCallback<T> txCallback,
                                          JobStoreSupport.TransactionValidator<T> txValidator)
                                   throws JobPersistenceException
```
    Execute the given callback having optionally acquired the given lock. This uses the non-managed transaction connection.
    
    Parameters:
    
    lockName - The name of the lock to acquire, for example "TRIGGER_ACCESS". If null, then no lock is acquired, but the lockCallback is still executed in a non-managed transaction.
    
    Throws:
    
    JobPersistenceException

Class JobStoreSupport

Nested Class Summary

Field Summary

Fields inherited from interface org.quartz.impl.jdbcjobstore.Constants

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

LOCK_TRIGGER_ACCESS

LOCK_STATE_ACCESS

dsName

tablePrefix

useProperties

instanceId

instanceName

delegateClassName

delegateInitString

delegateClass

calendarCache

maxToRecoverAtATime

sigChangeForTxCompletion

firstCheckIn

lastCheckin

Constructor Detail

JobStoreSupport

Method Detail

setDataSource

getDataSource

setTablePrefix

getTablePrefix

setUseProperties

canUseProperties

setInstanceId

getInstanceId

setInstanceName

setThreadPoolSize

setThreadExecutor

getThreadExecutor

getInstanceName

getEstimatedTimeToReleaseAndAcquireTrigger

setIsClustered

isClustered

getClusterCheckinInterval

setClusterCheckinInterval

getMaxMisfiresToHandleAtATime

setMaxMisfiresToHandleAtATime

getDbRetryInterval

setDbRetryInterval

setUseDBLocks

getUseDBLocks

isLockOnInsert

setLockOnInsert

getMisfireThreshold

setMisfireThreshold

isDontSetAutoCommitFalse

setDontSetAutoCommitFalse

isTxIsolationLevelSerializable

setTxIsolationLevelSerializable

isAcquireTriggersWithinLock

setAcquireTriggersWithinLock

setDriverDelegateClass

getDriverDelegateClass

setDriverDelegateInitString

getDriverDelegateInitString

getSelectWithLockSQL

setSelectWithLockSQL

getClassLoadHelper

getMakeThreadsDaemons

setMakeThreadsDaemons

isThreadsInheritInitializersClassLoadContext

setThreadsInheritInitializersClassLoadContext

getDoubleCheckLockMisfireHandler

setDoubleCheckLockMisfireHandler

getAcquireRetryDelay

getLog

initialize

schedulerStarted

schedulerPaused

schedulerResumed

shutdown