Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## org.quartz.impl.jdbcjobstore
Interface DriverDelegate

All Known Implementing Classes:
  CacheDelegate, CUBRIDDelegate, DB2v6Delegate, DB2v7Delegate, DB2v8Delegate, HSQLDBDelegate, MSSQLDelegate, OracleDelegate, PointbaseDelegate, PostgreSQLDelegate, StdJDBCDelegate, SybaseDelegate, WebLogicDelegate, WebLogicOracleDelegate

    public interface DriverDelegate

This is the base interface for all driver delegate classes.

This interface is very similar to the ``JobStore`` interface except each method has an additional ``Connection`` parameter.

Unless a database driver has some extremely-DB-specific requirements, any DriverDelegate implementation classes should extend the ``StdJDBCDelegate`` class.

Author:
  Jeffrey Wescott, James House

Method Summary
`boolean` | `calendarExists(Connection conn, String calendarName)` Check whether or not a calendar exists.
`boolean` | `calendarIsReferenced(Connection conn, String calendarName)` Check whether or not a calendar is referenced by any triggers.
`void` | `clearData(Connection conn)` Clear (delete!) all scheduling data - all `Job`s, `Trigger`s `Calendar`s.
`int` | `countMisfiredTriggersInState(Connection conn, String state1, long ts)` Get the number of triggers in the given state that have misfired - according to the given timestamp.
`int` | `deleteAllPausedTriggerGroups(Connection conn)`
`int` | `deleteCalendar(Connection conn, String calendarName)` Delete a calendar.
`int` | `deleteFiredTrigger(Connection conn, String entryId)` Delete a fired trigger.
`int` | `deleteFiredTriggers(Connection conn)` Delete all fired triggers.
`int` | `deleteFiredTriggers(Connection conn, String instanceId)` Delete all fired triggers of the given instance.
`int` | `deleteJobDetail(Connection conn, JobKey jobKey)` Delete the job detail record for the given job.
`int` | `deletePausedTriggerGroup(Connection conn, GroupMatcher<TriggerKey> matcher)`
`int` | `deletePausedTriggerGroup(Connection conn, String groupName)`
`int` | `deleteSchedulerState(Connection conn, String instanceId)` Delete a scheduler-instance state record.
`int` | `deleteTrigger(Connection conn, TriggerKey triggerKey)` Delete the base trigger data for a trigger.
`boolean` | `hasMisfiredTriggersInState(Connection conn, String state1, long ts, int count, List<TriggerKey> resultList)` Get the names of all of the triggers in the given states that have misfired - according to the given timestamp.
`void` | `initialize(org.slf4j.Logger logger, String tablePrefix, String schedName, String instanceId, ClassLoadHelper classLoadHelper, boolean useProperties, String initString)`
`int` | `insertCalendar(Connection conn, String calendarName, Calendar calendar)` Insert a new calendar.
`int` | `insertFiredTrigger(Connection conn, OperableTrigger trigger, String state, JobDetail jobDetail)` Insert a fired trigger.
`int` | `insertJobDetail(Connection conn, JobDetail job)` Insert the job detail record.
`int` | `insertPausedTriggerGroup(Connection conn, String groupName)`
`int` | `insertSchedulerState(Connection conn, String instanceId, long checkInTime, long interval)` Insert a scheduler-instance state record.
`int` | `insertTrigger(Connection conn, OperableTrigger trigger, String state, JobDetail jobDetail)` Insert the base trigger data.
`boolean` | `isExistingTriggerGroup(Connection conn, String groupName)`
`boolean` | `isJobNonConcurrent(Connection conn, JobKey jobKey)` Check whether or not the given job disallows concurrent execution.
`boolean` | `isTriggerGroupPaused(Connection conn, String groupName)`
`boolean` | `jobExists(Connection conn, JobKey jobKey)` Check whether or not the given job exists.
`Calendar` | `selectCalendar(Connection conn, String calendarName)` Select a calendar.
`List<String>` | `selectCalendars(Connection conn)` Select all of the stored calendars.
`Set<String>` | `selectFiredTriggerInstanceNames(Connection conn)` Select the distinct instance names of all fired-trigger records.
`List<FiredTriggerRecord>` | `selectFiredTriggerRecords(Connection conn, String triggerName, String groupName)` Select the states of all fired-trigger records for a given trigger, or trigger group if trigger name is `null`.
`List<FiredTriggerRecord>` | `selectFiredTriggerRecordsByJob(Connection conn, String jobName, String groupName)` Select the states of all fired-trigger records for a given job, or job group if job name is `null`.
`List<FiredTriggerRecord>` | `selectInstancesFiredTriggerRecords(Connection conn, String instanceName)` Select the states of all fired-trigger records for a given scheduler instance.
`JobDetail` | `selectJobDetail(Connection conn, JobKey jobKey, ClassLoadHelper loadHelper)` Select the JobDetail object for a given job name / group name.
`int` | `selectJobExecutionCount(Connection conn, JobKey jobKey)` Get the number instances of the identified job currently executing.
`JobDetail` | `selectJobForTrigger(Connection conn, ClassLoadHelper loadHelper, TriggerKey triggerKey)` Select the job to which the trigger is associated.
`JobDetail` | `selectJobForTrigger(Connection conn, ClassLoadHelper loadHelper, TriggerKey triggerKey, boolean loadJobClass)` Select the job to which the trigger is associated.
`List<String>` | `selectJobGroups(Connection conn)` Select all of the job group names that are stored.
`Set<JobKey>` | `selectJobsInGroup(Connection conn, GroupMatcher<JobKey> matcher)` Select all of the jobs contained in a given group.
`List<TriggerKey>` | `selectMisfiredTriggers(Connection conn, long ts)` Get the names of all of the triggers that have misfired - according to the given timestamp.
`List<TriggerKey>` | `selectMisfiredTriggersInGroupInState(Connection conn, String groupName, String state, long ts)` Get the names of all of the triggers in the given group and state that have misfired - according to the given timestamp.
`List<TriggerKey>` | `selectMisfiredTriggersInState(Connection conn, String state, long ts)` Get the names of all of the triggers in the given state that have misfired - according to the given timestamp.
`long` | `selectNextFireTime(Connection conn)` Deprecated. Does not account for misfires.
`int` | `selectNumCalendars(Connection conn)` Select the total number of calendars stored.
`int` | `selectNumJobs(Connection conn)` Select the total number of jobs stored.
`int` | `selectNumTriggers(Connection conn)` Select the total number of triggers stored.
`int` | `selectNumTriggersForJob(Connection conn, JobKey jobKey)` Select the number of triggers associated with a given job.
`Set<String>` | `selectPausedTriggerGroups(Connection conn)`
`List<SchedulerStateRecord>` | `selectSchedulerStateRecords(Connection conn, String instanceId)` A List of all current `SchedulerStateRecords`.
`OperableTrigger` | `selectTrigger(Connection conn, TriggerKey triggerKey)` Select a trigger.
`Key<?>` | `selectTriggerForFireTime(Connection conn, long fireTime)` Select the trigger that will be fired at the given fire time.
`List<String>` | `selectTriggerGroups(Connection conn)` Select all of the trigger group names that are stored.
`List<String>` | `selectTriggerGroups(Connection conn, GroupMatcher<TriggerKey> matcher)`
`JobDataMap` | `selectTriggerJobDataMap(Connection conn, String triggerName, String groupName)` Select a trigger's JobDataMap.
`List<TriggerKey>` | `selectTriggerKeysForJob(Connection conn, JobKey jobKey)` Get the names of all of the triggers associated with the given job.
`List<OperableTrigger>` | `selectTriggersForCalendar(Connection conn, String calName)` Select the triggers for a calendar
`List<OperableTrigger>` | `selectTriggersForJob(Connection conn, JobKey jobKey)` Select the triggers for a job
`List<OperableTrigger>` | `selectTriggersForRecoveringJobs(Connection conn)` Select all of the triggers for jobs that are requesting recovery.
`Set<TriggerKey>` | `selectTriggersInGroup(Connection conn, GroupMatcher<TriggerKey> matcher)` Select all of the triggers contained in a given group.
`List<TriggerKey>` | `selectTriggersInState(Connection conn, String state)` Select all of the triggers in a given state.
`String` | `selectTriggerState(Connection conn, TriggerKey triggerKey)` Select a trigger' state value.
`TriggerStatus` | `selectTriggerStatus(Connection conn, TriggerKey triggerKey)` Select a trigger' status (state & next fire time).
`List<TriggerKey>` | `selectTriggerToAcquire(Connection conn, long noLaterThan, long noEarlierThan)` Deprecated. - This remained for compatibility reason. Use `selectTriggerToAcquire(Connection, long, long, int)` instead.
`List<TriggerKey>` | `selectTriggerToAcquire(Connection conn, long noLaterThan, long noEarlierThan, int maxCount)` Select the next trigger which will fire to fire between the two given timestamps in ascending order of fire time, and then descending by priority.
`boolean` | `triggerExists(Connection conn, TriggerKey triggerKey)` Check whether or not a trigger exists.
`int` | `updateCalendar(Connection conn, String calendarName, Calendar calendar)` Update a calendar.
`int` | `updateFiredTrigger(Connection conn, OperableTrigger trigger, String state, JobDetail jobDetail)` Update a fired trigger record.
`int` | `updateJobData(Connection conn, JobDetail job)` Update the job data map for the given job.
`int` | `updateJobDetail(Connection conn, JobDetail job)` Update the job detail record.
`int` | `updateSchedulerState(Connection conn, String instanceId, long checkInTime)` Update a scheduler-instance state record.
`int` | `updateTrigger(Connection conn, OperableTrigger trigger, String state, JobDetail jobDetail)` Update the base trigger data.
`int` | `updateTriggerGroupStateFromOtherState(Connection conn, GroupMatcher<TriggerKey> matcher, String newState, String oldState)` Update all of the triggers of the given group to the given new state, if they are in the given old state.
`int` | `updateTriggerGroupStateFromOtherStates(Connection conn, GroupMatcher<TriggerKey> matcher, String newState, String oldState1, String oldState2, String oldState3)` Update all triggers in the given group to the given new state, if they are in one of the given old states.
`int` | `updateTriggerState(Connection conn, TriggerKey triggerKey, String state)` Update the state for a given trigger.
`int` | `updateTriggerStateFromOtherState(Connection conn, TriggerKey triggerKey, String newState, String oldState)` Update the given trigger to the given new state, if it is in the given old state.
`int` | `updateTriggerStateFromOtherStates(Connection conn, TriggerKey triggerKey, String newState, String oldState1, String oldState2, String oldState3)` Update the given trigger to the given new state, if it is one of the given old states.
`int` | `updateTriggerStatesForJob(Connection conn, JobKey jobKey, String state)` Update the states of all triggers associated with the given job.
`int` | `updateTriggerStatesForJobFromOtherState(Connection conn, JobKey jobKey, String state, String oldState)` Update the states of any triggers associated with the given job, that are the given current state.
`int` | `updateTriggerStatesFromOtherStates(Connection conn, String newState, String oldState1, String oldState2)` Update all triggers having one of the two given states, to the given new state.

Method Detail

### initialize

    void initialize(org.slf4j.Logger logger,
                    String tablePrefix,
                    String schedName,
                    String instanceId,
                    ClassLoadHelper classLoadHelper,
                    boolean useProperties,
                    String initString)
                    throws NoSuchDelegateException

  Parameters:
    `initString` - of the format: settingName=settingValue|otherSettingName=otherSettingValue|...
  Throws:
    `NoSuchDelegateException`

### updateTriggerStatesFromOtherStates

    int updateTriggerStatesFromOtherStates(Connection conn,
                                           String newState,
                                           String oldState1,
                                           String oldState2)
                                           throws SQLException

  Update all triggers having one of the two given states, to the given new state.

  Parameters:
    `conn` - the DB Connection
    `newState` - the new state for the triggers
    `oldState1` - the first old state to update
    `oldState2` - the second old state to update
  Returns:
    number of rows updated
  Throws:
    `SQLException`

### selectMisfiredTriggers

    List<TriggerKey> selectMisfiredTriggers(Connection conn,
                                            long ts)
                                            throws SQLException

  Get the names of all of the triggers that have misfired - according to the given timestamp.

  Parameters:
    `conn` - the DB Connection
  Returns:
    an array of ``Key`` objects
  Throws:
    `SQLException`

### selectMisfiredTriggersInState

    List<TriggerKey> selectMisfiredTriggersInState(Connection conn,
                                                   String state,
                                                   long ts)
                                                   throws SQLException

  Get the names of all of the triggers in the given state that have misfired - according to the given timestamp.

  Parameters:
    `conn` - the DB Connection
  Returns:
    an array of ``Key`` objects
  Throws:
    `SQLException`

### hasMisfiredTriggersInState

    boolean hasMisfiredTriggersInState(Connection conn,
                                       String state1,
                                       long ts,
                                       int count,
                                       List<TriggerKey> resultList)
                                       throws SQLException

  Get the names of all of the triggers in the given states that have misfired - according to the given timestamp. No more than count will be returned.

  Parameters:
    `conn` - the DB Connection
    `count` - the most misfired triggers to return, negative for all
    `resultList` - Output parameter. A List of ``Key`` objects. Must not be null.
  Returns:
    Whether there are more misfired triggers left to find beyond the given count.
  Throws:
    `SQLException`

### countMisfiredTriggersInState

    int countMisfiredTriggersInState(Connection conn,
                                     String state1,
                                     long ts)
                                     throws SQLException

  Get the number of triggers in the given state that have misfired - according to the given timestamp.

  Parameters:
    `conn` - the DB Connection
  Throws:
    `SQLException`

### selectMisfiredTriggersInGroupInState

    List<TriggerKey> selectMisfiredTriggersInGroupInState(Connection conn,
                                                          String groupName,
                                                          String state,
                                                          long ts)
                                                          throws SQLException

  Get the names of all of the triggers in the given group and state that have misfired - according to the given timestamp.

  Parameters:
    `conn` - the DB Connection
  Returns:
    an array of ``Key`` objects
  Throws:
    `SQLException`

### selectTriggersForRecoveringJobs

    List<OperableTrigger> selectTriggersForRecoveringJobs(Connection conn)
                                                          throws SQLException,
                                                                 IOException,
                                                                 ClassNotFoundException

  Select all of the triggers for jobs that are requesting recovery. The returned trigger objects will have unique "recoverXXX" trigger names and will be in the ``Scheduler`.DEFAULT_RECOVERY_GROUP` trigger group.

  In order to preserve the ordering of the triggers, the fire time will be set from the `COL_FIRED_TIME` column in the `TABLE_FIRED_TRIGGERS` table. The caller is responsible for calling `computeFirstFireTime` on each returned trigger. It is also up to the caller to insert the returned triggers to ensure that they are fired.

  Parameters:
    `conn` - the DB Connection
  Returns:
    an array of ``Trigger`` objects
  Throws:
    `SQLException`
    `IOException`
    `ClassNotFoundException`

### deleteFiredTriggers

    int deleteFiredTriggers(Connection conn)
                            throws SQLException

  Delete all fired triggers.

  Parameters:
    `conn` - the DB Connection
  Returns:
    the number of rows deleted
  Throws:
    `SQLException`

### deleteFiredTriggers

    int deleteFiredTriggers(Connection conn,
                            String instanceId)
                            throws SQLException

  Delete all fired triggers of the given instance.

  Parameters:
    `conn` - the DB Connection
  Returns:
    the number of rows deleted
  Throws:
    `SQLException`

### insertJobDetail

    int insertJobDetail(Connection conn,
                        JobDetail job)
                        throws IOException,
                               SQLException

  Insert the job detail record.

  Parameters:
    `conn` - the DB Connection
    `job` - the job to insert
  Returns:
    number of rows inserted
  Throws:
    `IOException` - if there were problems serializing the JobDataMap
    `SQLException`

### updateJobDetail

    int updateJobDetail(Connection conn,
                        JobDetail job)
                        throws IOException,
                               SQLException

  Update the job detail record.

  Parameters:
    `conn` - the DB Connection
    `job` - the job to update
  Returns:
    number of rows updated
  Throws:
    `IOException` - if there were problems serializing the JobDataMap
    `SQLException`

### selectTriggerKeysForJob

    List<TriggerKey> selectTriggerKeysForJob(Connection conn,
                                             JobKey jobKey)
                                             throws SQLException

  Get the names of all of the triggers associated with the given job.

  Parameters:
    `conn` - the DB Connection
  Returns:
    an array of ``Key`` objects
  Throws:
    `SQLException`

### deleteJobDetail

    int deleteJobDetail(Connection conn,
                        JobKey jobKey)
                        throws SQLException

  Delete the job detail record for the given job.

  Parameters:
    `conn` - the DB Connection
  Returns:
    the number of rows deleted
  Throws:
    `SQLException`

### isJobNonConcurrent

    boolean isJobNonConcurrent(Connection conn,
                               JobKey jobKey)
                               throws SQLException

  Check whether or not the given job disallows concurrent execution.

  Parameters:
    `conn` - the DB Connection
  Returns:
    true if the job exists and disallows concurrent execution, false otherwise
  Throws:
    `SQLException`

### jobExists

    boolean jobExists(Connection conn,
                      JobKey jobKey)
                      throws SQLException

  Check whether or not the given job exists.

  Parameters:
    `conn` - the DB Connection
  Returns:
    true if the job exists, false otherwise
  Throws:
    `SQLException`

### updateJobData

    int updateJobData(Connection conn,
                      JobDetail job)
                      throws IOException,
                             SQLException

  Update the job data map for the given job.

  Parameters:
    `conn` - the DB Connection
    `job` - the job to update
  Returns:
    the number of rows updated
  Throws:
    `IOException` - if there were problems serializing the JobDataMap
    `SQLException`

### selectJobDetail

    JobDetail selectJobDetail(Connection conn,
                              JobKey jobKey,
                              ClassLoadHelper loadHelper)
                              throws ClassNotFoundException,
                                     IOException,
                                     SQLException

  Select the JobDetail object for a given job name / group name.

  Parameters:
    `conn` - the DB Connection
  Returns:
    the populated JobDetail object
  Throws:
    `ClassNotFoundException` - if a class found during deserialization cannot be found or if the job class could not be found
    `IOException` - if deserialization causes an error
    `SQLException`

### selectNumJobs

    int selectNumJobs(Connection conn)
                      throws SQLException

  Select the total number of jobs stored.

  Parameters:
    `conn` - the DB Connection
  Returns:
    the total number of jobs stored
  Throws:
    `SQLException`

### selectJobGroups

    List<String> selectJobGroups(Connection conn)
                                 throws SQLException

  Select all of the job group names that are stored.

  Parameters:
    `conn` - the DB Connection
  Returns:
    an array of `String` group names
  Throws:
    `SQLException`

### selectJobsInGroup

    Set<JobKey> selectJobsInGroup(Connection conn,
                                  GroupMatcher<JobKey> matcher)
                                  throws SQLException

  Select all of the jobs contained in a given group.

  Parameters:
    `conn` - the DB Connection
    `matcher` - the group matcher to evaluate against the known jobs
  Returns:
    an array of `String` job names
  Throws:
    `SQLException`

### insertTrigger

    int insertTrigger(Connection conn,
                      OperableTrigger trigger,
                      String state,
                      JobDetail jobDetail)
                      throws SQLException,
                             IOException

  Insert the base trigger data.

  Parameters:
    `conn` - the DB Connection
    `trigger` - the trigger to insert
    `state` - the state that the trigger should be stored in
  Returns:
    the number of rows inserted
  Throws:
    `SQLException`
    `IOException`

### updateTrigger

    int updateTrigger(Connection conn,
                      OperableTrigger trigger,
                      String state,
                      JobDetail jobDetail)
                      throws SQLException,
                             IOException

  Update the base trigger data.

  Parameters:
    `conn` - the DB Connection
    `trigger` - the trigger to insert
    `state` - the state that the trigger should be stored in
  Returns:
    the number of rows updated
  Throws:
    `SQLException`
    `IOException`

### triggerExists

    boolean triggerExists(Connection conn,
                          TriggerKey triggerKey)
                          throws SQLException

  Check whether or not a trigger exists.

  Parameters:
    `conn` - the DB Connection
  Returns:
    the number of rows updated
  Throws:
    `SQLException`

### updateTriggerState

    int updateTriggerState(Connection conn,
                           TriggerKey triggerKey,
                           String state)
                           throws SQLException

  Update the state for a given trigger.

  Parameters:
    `conn` - the DB Connection
    `state` - the new state for the trigger
  Returns:
    the number of rows updated
  Throws:
    `SQLException`

### updateTriggerStateFromOtherState

    int updateTriggerStateFromOtherState(Connection conn,
                                         TriggerKey triggerKey,
                                         String newState,
                                         String oldState)
                                         throws SQLException

  Update the given trigger to the given new state, if it is in the given old state.

  Parameters:
    `conn` - the DB connection
    `newState` - the new state for the trigger
    `oldState` - the old state the trigger must be in
  Returns:
    int the number of rows updated
  Throws:
    `SQLException`

### updateTriggerStateFromOtherStates

    int updateTriggerStateFromOtherStates(Connection conn,
                                          TriggerKey triggerKey,
                                          String newState,
                                          String oldState1,
                                          String oldState2,
                                          String oldState3)
                                          throws SQLException

  Update the given trigger to the given new state, if it is one of the given old states.

  Parameters:
    `conn` - the DB connection
    `newState` - the new state for the trigger
    `oldState1` - one of the old state the trigger must be in
    `oldState2` - one of the old state the trigger must be in
    `oldState3` - one of the old state the trigger must be in
  Returns:
    int the number of rows updated
  Throws:
    `SQLException`

### updateTriggerGroupStateFromOtherStates

    int updateTriggerGroupStateFromOtherStates(Connection conn,
                                               GroupMatcher<TriggerKey> matcher,
                                               String newState,
                                               String oldState1,
                                               String oldState2,
                                               String oldState3)
                                               throws SQLException

  Update all triggers in the given group to the given new state, if they are in one of the given old states.

  Parameters:
    `conn` - the DB connection
    `matcher` - the group matcher to evaluate against the known triggers
    `newState` - the new state for the trigger
    `oldState1` - one of the old state the trigger must be in
    `oldState2` - one of the old state the trigger must be in
    `oldState3` - one of the old state the trigger must be in
  Returns:
    int the number of rows updated
  Throws:
    `SQLException`

### updateTriggerGroupStateFromOtherState

    int updateTriggerGroupStateFromOtherState(Connection conn,
                                              GroupMatcher<TriggerKey> matcher,
                                              String newState,
                                              String oldState)
                                              throws SQLException

  Update all of the triggers of the given group to the given new state, if they are in the given old state.

  Parameters:
    `conn` - the DB connection
    `matcher` - the matcher to evaluate against the known triggers
    `newState` - the new state for the trigger group
    `oldState` - the old state the triggers must be in
  Returns:
    int the number of rows updated
  Throws:
    `SQLException`

### updateTriggerStatesForJob

    int updateTriggerStatesForJob(Connection conn,
                                  JobKey jobKey,
                                  String state)
                                  throws SQLException

  Update the states of all triggers associated with the given job.

  Parameters:
    `conn` - the DB Connection
    `state` - the new state for the triggers
  Returns:
    the number of rows updated
  Throws:
    `SQLException`

### updateTriggerStatesForJobFromOtherState

    int updateTriggerStatesForJobFromOtherState(Connection conn,
                                                JobKey jobKey,
                                                String state,
                                                String oldState)
                                                throws SQLException

  Update the states of any triggers associated with the given job, that are the given current state.

  Parameters:
    `conn` - the DB Connection
    `state` - the new state for the triggers
    `oldState` - the old state of the triggers
  Returns:
    the number of rows updated
  Throws:
    `SQLException`

### deleteTrigger

    int deleteTrigger(Connection conn,
                      TriggerKey triggerKey)
                      throws SQLException

  Delete the base trigger data for a trigger.

  Parameters:
    `conn` - the DB Connection
  Returns:
    the number of rows deleted
  Throws:
    `SQLException`

### selectNumTriggersForJob

    int selectNumTriggersForJob(Connection conn,
                                JobKey jobKey)
                                throws SQLException

  Select the number of triggers associated with a given job.

  Parameters:
    `conn` - the DB Connection
  Returns:
    the number of triggers for the given job
  Throws:
    `SQLException`

### selectJobForTrigger

    JobDetail selectJobForTrigger(Connection conn,
                                  ClassLoadHelper loadHelper,
                                  TriggerKey triggerKey)
                                  throws ClassNotFoundException,
                                         SQLException

  Select the job to which the trigger is associated.

  Parameters:
    `conn` - the DB Connection
  Returns:
    the ``JobDetail`` object associated with the given trigger
  Throws:
    `ClassNotFoundException`
    `SQLException`

### selectJobForTrigger

    JobDetail selectJobForTrigger(Connection conn,
                                  ClassLoadHelper loadHelper,
                                  TriggerKey triggerKey,
                                  boolean loadJobClass)
                                  throws ClassNotFoundException,
                                         SQLException

  Select the job to which the trigger is associated. Allow option to load actual job class or not. When case of remove, we do not need to load the class, which in many cases, it's no longer exists.

  Throws:
    `ClassNotFoundException`
    `SQLException`

### selectTriggersForJob

    List<OperableTrigger> selectTriggersForJob(Connection conn,
                                               JobKey jobKey)
                                               throws SQLException,
                                                      ClassNotFoundException,
                                                      IOException,
                                                      JobPersistenceException

  Select the triggers for a job

  Parameters:
    `conn` - the DB Connection
  Returns:
    an array of `(@link org.quartz.Trigger)` objects associated with a given job.
  Throws:
    `SQLException`
    `JobPersistenceException`
    `ClassNotFoundException`
    `IOException`

### selectTriggersForCalendar

    List<OperableTrigger> selectTriggersForCalendar(Connection conn,
                                                    String calName)
                                                    throws SQLException,
                                                           ClassNotFoundException,
                                                           IOException,
                                                           JobPersistenceException

  Select the triggers for a calendar

  Parameters:
    `conn` - the DB Connection
    `calName` - the name of the calendar
  Returns:
    an array of `(@link org.quartz.Trigger)` objects associated with the given calendar.
  Throws:
    `SQLException`
    `JobPersistenceException`
    `ClassNotFoundException`
    `IOException`

### selectTrigger

    OperableTrigger selectTrigger(Connection conn,
                                  TriggerKey triggerKey)
                                  throws SQLException,
                                         ClassNotFoundException,
                                         IOException,
                                         JobPersistenceException

  Select a trigger.

  Parameters:
    `conn` - the DB Connection
  Returns:
    the ``Trigger`` object
  Throws:
    `JobPersistenceException`
    `SQLException`
    `ClassNotFoundException`
    `IOException`

### selectTriggerJobDataMap

    JobDataMap selectTriggerJobDataMap(Connection conn,
                                       String triggerName,
                                       String groupName)
                                       throws SQLException,
                                              ClassNotFoundException,
                                              IOException

  Select a trigger's JobDataMap.

  Parameters:
    `conn` - the DB Connection
    `triggerName` - the name of the trigger
    `groupName` - the group containing the trigger
  Returns:
    the ``JobDataMap`` of the Trigger, never null, but possibly empty.
  Throws:
    `SQLException`
    `ClassNotFoundException`
    `IOException`

### selectTriggerState

    String selectTriggerState(Connection conn,
                              TriggerKey triggerKey)
                              throws SQLException

  Select a trigger' state value.

  Parameters:
    `conn` - the DB Connection
  Returns:
    the ``Trigger`` object
  Throws:
    `SQLException`

### selectTriggerStatus

    TriggerStatus selectTriggerStatus(Connection conn,
                                      TriggerKey triggerKey)
                                      throws SQLException

  Select a trigger' status (state & next fire time).

  Parameters:
    `conn` - the DB Connection
  Returns:
    a `TriggerStatus` object, or null
  Throws:
    `SQLException`

### selectNumTriggers

    int selectNumTriggers(Connection conn)
                          throws SQLException

  Select the total number of triggers stored.

  Parameters:
    `conn` - the DB Connection
  Returns:
    the total number of triggers stored
  Throws:
    `SQLException`

### selectTriggerGroups

    List<String> selectTriggerGroups(Connection conn)
                                     throws SQLException

  Select all of the trigger group names that are stored.

  Parameters:
    `conn` - the DB Connection
  Returns:
    an array of `String` group names
  Throws:
    `SQLException`

### selectTriggerGroups

    List<String> selectTriggerGroups(Connection conn,
                                     GroupMatcher<TriggerKey> matcher)
                                     throws SQLException

  Throws:
    `SQLException`

### selectTriggersInGroup

    Set<TriggerKey> selectTriggersInGroup(Connection conn,
                                          GroupMatcher<TriggerKey> matcher)
                                          throws SQLException

  Select all of the triggers contained in a given group.

  Parameters:
    `conn` - the DB Connection
    `matcher` - to evaluate against known triggers
  Returns:
    a Set of `TriggerKey`s
  Throws:
    `SQLException`

### selectTriggersInState

    List<TriggerKey> selectTriggersInState(Connection conn,
                                           String state)
                                           throws SQLException

  Select all of the triggers in a given state.

  Parameters:
    `conn` - the DB Connection
    `state` - the state the triggers must be in
  Returns:
    an array of trigger `Key` s
  Throws:
    `SQLException`

### insertPausedTriggerGroup

    int insertPausedTriggerGroup(Connection conn,
                                 String groupName)
                                 throws SQLException

  Throws:
    `SQLException`

### deletePausedTriggerGroup

    int deletePausedTriggerGroup(Connection conn,
                                 String groupName)
                                 throws SQLException

  Throws:
    `SQLException`

### deletePausedTriggerGroup

    int deletePausedTriggerGroup(Connection conn,
                                 GroupMatcher<TriggerKey> matcher)
                                 throws SQLException

  Throws:
    `SQLException`

### deleteAllPausedTriggerGroups

    int deleteAllPausedTriggerGroups(Connection conn)
                                     throws SQLException

  Throws:
    `SQLException`

### isTriggerGroupPaused

    boolean isTriggerGroupPaused(Connection conn,
                                 String groupName)
                                 throws SQLException

  Throws:
    `SQLException`

### selectPausedTriggerGroups

    Set<String> selectPausedTriggerGroups(Connection conn)
                                          throws SQLException

  Throws:
    `SQLException`

### isExistingTriggerGroup

    boolean isExistingTriggerGroup(Connection conn,
                                   String groupName)
                                   throws SQLException

  Throws:
    `SQLException`

### insertCalendar

    int insertCalendar(Connection conn,
                       String calendarName,
                       Calendar calendar)
                       throws IOException,
                              SQLException

  Insert a new calendar.

  Parameters:
    `conn` - the DB Connection
    `calendarName` - the name for the new calendar
    `calendar` - the calendar
  Returns:
    the number of rows inserted
  Throws:
    `IOException` - if there were problems serializing the calendar
    `SQLException`

### updateCalendar

    int updateCalendar(Connection conn,
                       String calendarName,
                       Calendar calendar)
                       throws IOException,
                              SQLException

  Update a calendar.

  Parameters:
    `conn` - the DB Connection
    `calendarName` - the name for the new calendar
    `calendar` - the calendar
  Returns:
    the number of rows updated
  Throws:
    `IOException` - if there were problems serializing the calendar
    `SQLException`

### calendarExists

    boolean calendarExists(Connection conn,
                           String calendarName)
                           throws SQLException

  Check whether or not a calendar exists.

  Parameters:
    `conn` - the DB Connection
    `calendarName` - the name of the calendar
  Returns:
    true if the trigger exists, false otherwise
  Throws:
    `SQLException`

### selectCalendar

    Calendar selectCalendar(Connection conn,
                            String calendarName)
                            throws ClassNotFoundException,
                                   IOException,
                                   SQLException

  Select a calendar.

  Parameters:
    `conn` - the DB Connection
    `calendarName` - the name of the calendar
  Returns:
    the Calendar
  Throws:
    `ClassNotFoundException` - if a class found during deserialization cannot be found be found
    `IOException` - if there were problems deserializing the calendar
    `SQLException`

### calendarIsReferenced

    boolean calendarIsReferenced(Connection conn,
                                 String calendarName)
                                 throws SQLException

  Check whether or not a calendar is referenced by any triggers.

  Parameters:
    `conn` - the DB Connection
    `calendarName` - the name of the calendar
  Returns:
    true if any triggers reference the calendar, false otherwise
  Throws:
    `SQLException`

### deleteCalendar

    int deleteCalendar(Connection conn,
                       String calendarName)
                       throws SQLException

  Delete a calendar.

  Parameters:
    `conn` - the DB Connection
    `calendarName` - the name of the trigger
  Returns:
    the number of rows deleted
  Throws:
    `SQLException`

### selectNumCalendars

    int selectNumCalendars(Connection conn)
                           throws SQLException

  Select the total number of calendars stored.

  Parameters:
    `conn` - the DB Connection
  Returns:
    the total number of calendars stored
  Throws:
    `SQLException`

### selectCalendars

    List<String> selectCalendars(Connection conn)
                                 throws SQLException

  Select all of the stored calendars.

  Parameters:
    `conn` - the DB Connection
  Returns:
    an array of `String` calendar names
  Throws:
    `SQLException`

### selectNextFireTime

    long selectNextFireTime(Connection conn)
                            throws SQLException

  Deprecated. Does not account for misfires.

  Select the next time that a trigger will be fired.

  Parameters:
    `conn` - the DB Connection
  Returns:
    the next fire time, or 0 if no trigger will be fired
  Throws:
    `SQLException`

### selectTriggerForFireTime

    Key<?> selectTriggerForFireTime(Connection conn,
                                    long fireTime)
                                    throws SQLException

  Select the trigger that will be fired at the given fire time.

  Parameters:
    `conn` - the DB Connection
    `fireTime` - the time that the trigger will be fired
  Returns:
    a ``Key`` representing the trigger that will be fired at the given fire time, or null if no trigger will be fired at that time
  Throws:
    `SQLException`

### selectTriggerToAcquire

    List<TriggerKey> selectTriggerToAcquire(Connection conn,
                                            long noLaterThan,
                                            long noEarlierThan)
                                            throws SQLException

  Deprecated. - This remained for compatibility reason. Use `selectTriggerToAcquire(Connection, long, long, int)` instead.

  Select the next trigger which will fire to fire between the two given timestamps in ascending order of fire time, and then descending by priority.

  Parameters:
    `conn` - the DB Connection
    `noLaterThan` - highest value of `getNextFireTime()` of the triggers (exclusive)
    `noEarlierThan` - highest value of `getNextFireTime()` of the triggers (inclusive)
  Returns:
    A (never null, possibly empty) list of the identifiers (Key objects) of the next triggers to be fired.
  Throws:
    `SQLException`

### selectTriggerToAcquire

    List<TriggerKey> selectTriggerToAcquire(Connection conn,
                                            long noLaterThan,
                                            long noEarlierThan,
                                            int maxCount)
                                            throws SQLException

  Select the next trigger which will fire to fire between the two given timestamps in ascending order of fire time, and then descending by priority.

  Parameters:
    `conn` - the DB Connection
    `noLaterThan` - highest value of `getNextFireTime()` of the triggers (exclusive)
    `noEarlierThan` - highest value of `getNextFireTime()` of the triggers (inclusive)
    `maxCount` - maximum number of trigger keys allow to acquired in the returning list.
  Returns:
    A (never null, possibly empty) list of the identifiers (Key objects) of the next triggers to be fired.
  Throws:
    `SQLException`

### insertFiredTrigger

    int insertFiredTrigger(Connection conn,
                           OperableTrigger trigger,
                           String state,
                           JobDetail jobDetail)
                           throws SQLException

  Insert a fired trigger.

  Parameters:
    `conn` - the DB Connection
    `trigger` - the trigger
    `state` - the state that the trigger should be stored in
  Returns:
    the number of rows inserted
  Throws:
    `SQLException`

### updateFiredTrigger

    int updateFiredTrigger(Connection conn,
                           OperableTrigger trigger,
                           String state,
                           JobDetail jobDetail)
                           throws SQLException

  Update a fired trigger record. Will update the fields "firing instance", "fire time", and "state".

  Parameters:
    `conn` - the DB Connection
    `trigger` - the trigger
    `state` - the state that the trigger should be stored in
  Returns:
    the number of rows inserted
  Throws:
    `SQLException`

### selectFiredTriggerRecords

    List<FiredTriggerRecord> selectFiredTriggerRecords(Connection conn,
                                                       String triggerName,
                                                       String groupName)
                                                       throws SQLException

  Select the states of all fired-trigger records for a given trigger, or trigger group if trigger name is `null`.

  Returns:
    a List of FiredTriggerRecord objects.
  Throws:
    `SQLException`

### selectFiredTriggerRecordsByJob

    List<FiredTriggerRecord> selectFiredTriggerRecordsByJob(Connection conn,
                                                            String jobName,
                                                            String groupName)
                                                            throws SQLException

  Select the states of all fired-trigger records for a given job, or job group if job name is `null`.

  Returns:
    a List of FiredTriggerRecord objects.
  Throws:
    `SQLException`

### selectInstancesFiredTriggerRecords

    List<FiredTriggerRecord> selectInstancesFiredTriggerRecords(Connection conn,
                                                                String instanceName)
                                                                throws SQLException

  Select the states of all fired-trigger records for a given scheduler instance.

  Returns:
    a List of FiredTriggerRecord objects.
  Throws:
    `SQLException`

### selectFiredTriggerInstanceNames

    Set<String> selectFiredTriggerInstanceNames(Connection conn)
                                                throws SQLException

  Select the distinct instance names of all fired-trigger records.

  This is useful when trying to identify orphaned fired triggers (a fired trigger without a scheduler state record.)

  Returns:
    a Set of String objects.
  Throws:
    `SQLException`

### deleteFiredTrigger

    int deleteFiredTrigger(Connection conn,
                           String entryId)
                           throws SQLException

  Delete a fired trigger.

  Parameters:
    `conn` - the DB Connection
    `entryId` - the fired trigger entry to delete
  Returns:
    the number of rows deleted
  Throws:
    `SQLException`

### selectJobExecutionCount

    int selectJobExecutionCount(Connection conn,
                                JobKey jobKey)
                                throws SQLException

  Get the number instances of the identified job currently executing.

  Parameters:
    `conn` - the DB Connection
  Returns:
    the number instances of the identified job currently executing.
  Throws:
    `SQLException`

### insertSchedulerState

    int insertSchedulerState(Connection conn,
                             String instanceId,
                             long checkInTime,
                             long interval)
                             throws SQLException

  Insert a scheduler-instance state record.

  Parameters:
    `conn` - the DB Connection
  Returns:
    the number of inserted rows.
  Throws:
    `SQLException`

### deleteSchedulerState

    int deleteSchedulerState(Connection conn,
                             String instanceId)
                             throws SQLException

  Delete a scheduler-instance state record.

  Parameters:
    `conn` - the DB Connection
  Returns:
    the number of deleted rows.
  Throws:
    `SQLException`

### updateSchedulerState

    int updateSchedulerState(Connection conn,
                             String instanceId,
                             long checkInTime)
                             throws SQLException

  Update a scheduler-instance state record.

  Parameters:
    `conn` - the DB Connection
  Returns:
    the number of updated rows.
  Throws:
    `SQLException`

### selectSchedulerStateRecords

    List<SchedulerStateRecord> selectSchedulerStateRecords(Connection conn,
                                                           String instanceId)
                                                           throws SQLException

  A List of all current `SchedulerStateRecords`.

  If instanceId is not null, then only the record for the identified instance will be returned.

  Parameters:
    `conn` - the DB Connection
  Throws:
    `SQLException`

### clearData

    void clearData(Connection conn)
                   throws SQLException

  Clear (delete!) all scheduling data - all `Job`s, `Trigger`s `Calendar`s.

  Throws:
    `JobPersistenceException`
    `SQLException`

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

Copyright 2001-2016, Terracotta, Inc.