public StdJDBCDelegate(Log logger,
    String tablePrefix,
    String instanceId) 
{
    /*
     * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     * 
     * Constructors.
     * 
     * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     */
        this.logger = logger;
        this.tablePrefix = tablePrefix;
        this.instanceId = instanceId;
}

Create new StdJDBCDelegate instance.

Parameters:

logger - the logger to use during execution

tablePrefix - the prefix of all table names

 public StdJDBCDelegate(Log logger,
    String tablePrefix,
    String instanceId,
    Boolean useProperties) 
{
        this.logger = logger;
        this.tablePrefix = tablePrefix;
        this.instanceId = instanceId;
        this.useProperties = useProperties.booleanValue();
}

Create new StdJDBCDelegate instance.

Parameters:

logger - the logger to use during execution

tablePrefix - the prefix of all table names

 public boolean calendarExists(Connection conn,
    String calendarName) throws SQLException 
{
        PreparedStatement ps = null;
        ResultSet rs = null;
        try {
            ps = conn.prepareStatement(rtp(SELECT_CALENDAR_EXISTENCE));
            ps.setString(1, calendarName);
            rs = ps.executeQuery();
            if (rs.next()) {
                return true;
            } else {
                return false;
            }
        } finally {
            closeResultSet(rs);
            closeStatement(ps);
        }
}

Check whether or not a calendar exists.

 public boolean calendarIsReferenced(Connection conn,
    String calendarName) throws SQLException 
{
        PreparedStatement ps = null;
        ResultSet rs = null;
        try {
            ps = conn.prepareStatement(rtp(SELECT_REFERENCED_CALENDAR));
            ps.setString(1, calendarName);
            rs = ps.executeQuery();
            if (rs.next()) {
                return true;
            } else {
                return false;
            }
        } finally {
            closeResultSet(rs);
            closeStatement(ps);
        }
}

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

 protected boolean canUseProperties() 
{
        return useProperties;
}

 protected  void closeResultSet(ResultSet rs) 
{
        if (null != rs) {
            try {
                rs.close();
            } catch (SQLException ignore) {
            }
        }
}

Cleanup helper method that closes the given ResultSet while ignoring any errors.

 protected  void closeStatement(Statement statement) 
{
        if (null != statement) {
            try {
                statement.close();
            } catch (SQLException ignore) {
            }
        }
}

Cleanup helper method that closes the given Statement while ignoring any errors.

 protected Map convertFromProperty(Properties properties) throws IOException 
{
        return new HashMap(properties);
}

convert the JobDataMap into a list of properties

 protected Properties convertToProperty(Map data) throws IOException 
{
        Properties properties = new Properties();
        for (Iterator entryIter = data.entrySet().iterator(); entryIter.hasNext();) {
            Map.Entry entry = (Map.Entry)entryIter.next();
            Object key = entry.getKey();
            Object val = (entry.getValue() == null) ? "" : entry.getValue();
            if(!(key instanceof String)) {
                throw new IOException("JobDataMap keys/values must be Strings " 
                        + "when the 'useProperties' property is set. " 
                        + " offending Key: " + key);
            }
            if(!(val instanceof String)) {
                throw new IOException("JobDataMap values must be Strings " 
                        + "when the 'useProperties' property is set. " 
                        + " Key of offending value: " + key);
            }
            properties.put(key, val);
        }
        return properties;
}

convert the JobDataMap into a list of properties

 public int countMisfiredTriggersInStates(Connection conn,
    String state1,
    String state2,
    long ts) throws SQLException 
{
        PreparedStatement ps = null;
        ResultSet rs = null;
        try {
            ps = conn.prepareStatement(rtp(COUNT_MISFIRED_TRIGGERS_IN_STATES));
            ps.setBigDecimal(1, new BigDecimal(String.valueOf(ts)));
            ps.setString(2, state1);
            ps.setString(3, state2);
            rs = ps.executeQuery();
            if (rs.next()) {
                return rs.getInt(1);
            }
            throw new SQLException("No misfired trigger count returned.");
        } finally {
            closeResultSet(rs);
            closeStatement(ps);
        }
}

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

 public int deleteAllPausedTriggerGroups(Connection conn) throws SQLException 
{
        PreparedStatement ps = null;
        try {
            ps = conn.prepareStatement(rtp(DELETE_PAUSED_TRIGGER_GROUPS));
            int rows = ps.executeUpdate();
            return rows;
        } finally {
            closeStatement(ps);
        }
}

 public int deleteBlobTrigger(Connection conn,
    String triggerName,
    String groupName) throws SQLException 
{
        PreparedStatement ps = null;
        try {
            ps = conn.prepareStatement(rtp(DELETE_BLOB_TRIGGER));
            ps.setString(1, triggerName);
            ps.setString(2, groupName);
            return ps.executeUpdate();
        } finally {
            closeStatement(ps);
        }
}

Delete the cron trigger data for a trigger.

 public int deleteCalendar(Connection conn,
    String calendarName) throws SQLException 
{
        PreparedStatement ps = null;
        try {
            ps = conn.prepareStatement(rtp(DELETE_CALENDAR));
            ps.setString(1, calendarName);
            return ps.executeUpdate();
        } finally {
            closeStatement(ps);
        }
}

Delete a calendar.

 public int deleteCronTrigger(Connection conn,
    String triggerName,
    String groupName) throws SQLException 
{
        PreparedStatement ps = null;
        try {
            ps = conn.prepareStatement(rtp(DELETE_CRON_TRIGGER));
            ps.setString(1, triggerName);
            ps.setString(2, groupName);
            return ps.executeUpdate();
        } finally {
            closeStatement(ps);
        }
}

Delete the cron trigger data for a trigger.

 public int deleteFiredTrigger(Connection conn,
    String entryId) throws SQLException 
{
        PreparedStatement ps = null;
        try {
            ps = conn.prepareStatement(rtp(DELETE_FIRED_TRIGGER));
            ps.setString(1, entryId);
            return ps.executeUpdate();
        } finally {
            closeStatement(ps);
        }
}

Delete a fired trigger.

 public int deleteFiredTriggers(Connection conn) throws SQLException 
{
        PreparedStatement ps = null;
        try {
            ps = conn.prepareStatement(rtp(DELETE_FIRED_TRIGGERS));
            return ps.executeUpdate();
        } finally {
            closeStatement(ps);
        }
}

Delete all fired triggers.

 public int deleteFiredTriggers(Connection conn,
    String instanceId) throws SQLException 
{
        PreparedStatement ps = null;
        try {
            ps = conn.prepareStatement(rtp(DELETE_INSTANCES_FIRED_TRIGGERS));
            ps.setString(1, instanceId);
            return ps.executeUpdate();
        } finally {
            closeStatement(ps);
        }
}

 public int deleteJobDetail(Connection conn,
    String jobName,
    String groupName) throws SQLException 
{
        PreparedStatement ps = null;
        try {
            if (logger.isDebugEnabled()) {
                logger.debug("Deleting job: " + groupName + "." + jobName);
            }
            ps = conn.prepareStatement(rtp(DELETE_JOB_DETAIL));
            ps.setString(1, jobName);
            ps.setString(2, groupName);
            return ps.executeUpdate();
        } finally {
            closeStatement(ps);
        }
}

Delete the job detail record for the given job.

 public int deleteJobListeners(Connection conn,
    String jobName,
    String groupName) throws SQLException 
{
        PreparedStatement ps = null;
        try {
            ps = conn.prepareStatement(rtp(DELETE_JOB_LISTENERS));
            ps.setString(1, jobName);
            ps.setString(2, groupName);
            return ps.executeUpdate();
        } finally {
            closeStatement(ps);
        }
}

Delete all job listeners for the given job.

 public int deletePausedTriggerGroup(Connection conn,
    String groupName) throws SQLException 
{
        PreparedStatement ps = null;
        try {
            ps = conn.prepareStatement(rtp(DELETE_PAUSED_TRIGGER_GROUP));
            ps.setString(1, groupName);
            int rows = ps.executeUpdate();
            return rows;
        } finally {
            closeStatement(ps);
        }
}

 public int deleteSchedulerState(Connection conn,
    String instanceId) throws SQLException 
{
        PreparedStatement ps = null;
        try {
            ps = conn.prepareStatement(rtp(DELETE_SCHEDULER_STATE));
            ps.setString(1, instanceId);
            return ps.executeUpdate();
        } finally {
            closeStatement(ps);
        }
}

 public int deleteSimpleTrigger(Connection conn,
    String triggerName,
    String groupName) throws SQLException 
{
        PreparedStatement ps = null;
        try {
            ps = conn.prepareStatement(rtp(DELETE_SIMPLE_TRIGGER));
            ps.setString(1, triggerName);
            ps.setString(2, groupName);
            return ps.executeUpdate();
        } finally {
            closeStatement(ps);
        }
}

Delete the simple trigger data for a trigger.

 public int deleteTrigger(Connection conn,
    String triggerName,
    String groupName) throws SQLException 
{
        PreparedStatement ps = null;
        try {
            ps = conn.prepareStatement(rtp(DELETE_TRIGGER));
            ps.setString(1, triggerName);
            ps.setString(2, groupName);
            return ps.executeUpdate();
        } finally {
            closeStatement(ps);
        }
}

Delete the base trigger data for a trigger.

 public int deleteTriggerListeners(Connection conn,
    String triggerName,
    String groupName) throws SQLException 
{
        PreparedStatement ps = null;
        try {
            ps = conn.prepareStatement(rtp(DELETE_TRIGGER_LISTENERS));
            ps.setString(1, triggerName);
            ps.setString(2, groupName);
            return ps.executeUpdate();
        } finally {
            closeStatement(ps);
        }
}

Delete all of the listeners associated with a given trigger.

 public int deleteVolatileFiredTriggers(Connection conn) throws SQLException 
{
        PreparedStatement ps = null;
        try {
            ps = conn.prepareStatement(rtp(DELETE_VOLATILE_FIRED_TRIGGERS));
            setBoolean(ps, 1, true);
            return ps.executeUpdate();
        } finally {
            closeStatement(ps);
        }
}

 protected boolean getBoolean(ResultSet rs,
    String columnName) throws SQLException 
{
        return rs.getBoolean(columnName);
}

Retrieves the value of the designated column in the current row as a boolean. This just wraps ResultSet#getBoolean(java.lang.String) by default, but it can be overloaded by subclass delegates for databases that don't explicitly support the boolean type.

 protected boolean getBoolean(ResultSet rs,
    int columnIndex) throws SQLException 
{
        return rs.getBoolean(columnIndex);
}

Retrieves the value of the designated column index in the current row as a boolean. This just wraps ResultSet#getBoolean(java.lang.String) by default, but it can be overloaded by subclass delegates for databases that don't explicitly support the boolean type.

 protected Object getJobDetailFromBlob(ResultSet rs,
    String colName) throws IOException, ClassNotFoundException, SQLException 
{
        if (canUseProperties()) {
            Blob blobLocator = rs.getBlob(colName);
            if (blobLocator != null) {
                InputStream binaryInput = blobLocator.getBinaryStream();
                return binaryInput;
            } else {
                return null;
            }
        }
        return getObjectFromBlob(rs, colName);
}

This method should be overridden by any delegate subclasses that need special handling for BLOBs for job details. The default implementation uses standard JDBC java.sql.Blob operations.

 protected Object getKeyOfNonSerializableValue(Map data) 
{
        for (Iterator entryIter = data.entrySet().iterator(); entryIter.hasNext();) {
            Map.Entry entry = (Map.Entry)entryIter.next();
            ByteArrayOutputStream baos = null;
            try {
                serializeObject(entry.getValue());
            } catch (IOException e) {
                return entry.getKey();
            } finally {
                if (baos != null) {
                    try { baos.close(); } catch (IOException ignore) {}
                }
            }
        }
        // As long as it is true that the Map was not serializable, we should
        // not hit this case.
        return null;
}

Find the key of the first non-serializable value in the given Map.

 protected Object getObjectFromBlob(ResultSet rs,
    String colName) throws IOException, ClassNotFoundException, SQLException 
{
        Object obj = null;
        Blob blobLocator = rs.getBlob(colName);
        if (blobLocator != null) {
            InputStream binaryInput = blobLocator.getBinaryStream();
            if (null != binaryInput) {
                if (binaryInput instanceof ByteArrayInputStream
                    && ((ByteArrayInputStream) binaryInput).available() == 0 ) {
                    //do nothing
                }
                else {
                    ObjectInputStream in = new ObjectInputStream(binaryInput);
                    try {
                        obj = in.readObject();
                    } finally {
                        in.close();
                    }
                }
            }
        }
        return obj;
}

This method should be overridden by any delegate subclasses that need special handling for BLOBs. The default implementation uses standard JDBC java.sql.Blob operations.

 public int insertBlobTrigger(Connection conn,
    Trigger trigger) throws IOException, SQLException 
{
        PreparedStatement ps = null;
        ByteArrayOutputStream os = null;
        try {
            // update the blob
            os = new ByteArrayOutputStream();
            ObjectOutputStream oos = new ObjectOutputStream(os);
            oos.writeObject(trigger);
            oos.close();
            byte[] buf = os.toByteArray();
            ByteArrayInputStream is = new ByteArrayInputStream(buf);
            ps = conn.prepareStatement(rtp(INSERT_BLOB_TRIGGER));
            ps.setString(1, trigger.getName());
            ps.setString(2, trigger.getGroup());
            ps.setBinaryStream(3, is, buf.length);
            return ps.executeUpdate();
        } finally {
            closeStatement(ps);
        }
}

Insert the blob trigger data.

 public int insertCalendar(Connection conn,
    String calendarName,
    Calendar calendar) throws IOException, SQLException 
{
        ByteArrayOutputStream baos = serializeObject(calendar);
        PreparedStatement ps = null;
        try {
            ps = conn.prepareStatement(rtp(INSERT_CALENDAR));
            ps.setString(1, calendarName);
            setBytes(ps, 2, baos);
            return ps.executeUpdate();
        } finally {
            closeStatement(ps);
        }
}

Insert a new calendar.

 public int insertCronTrigger(Connection conn,
    CronTrigger trigger) throws SQLException 
{
        PreparedStatement ps = null;
        try {
            ps = conn.prepareStatement(rtp(INSERT_CRON_TRIGGER));
            ps.setString(1, trigger.getName());
            ps.setString(2, trigger.getGroup());
            ps.setString(3, trigger.getCronExpression());
            ps.setString(4, trigger.getTimeZone().getID());
            return ps.executeUpdate();
        } finally {
            closeStatement(ps);
        }
}

Insert the cron trigger data.

 public int insertFiredTrigger(Connection conn,
    Trigger trigger,
    String state,
    JobDetail job) throws SQLException 
{
        PreparedStatement ps = null;
        try {
            ps = conn.prepareStatement(rtp(INSERT_FIRED_TRIGGER));
            ps.setString(1, trigger.getFireInstanceId());
            ps.setString(2, trigger.getName());
            ps.setString(3, trigger.getGroup());
            setBoolean(ps, 4, trigger.isVolatile());
            ps.setString(5, instanceId);
            ps.setBigDecimal(6, new BigDecimal(String.valueOf(trigger
                    .getNextFireTime().getTime())));
            ps.setString(7, state);
            if (job != null) {
                ps.setString(8, trigger.getJobName());
                ps.setString(9, trigger.getJobGroup());
                setBoolean(ps, 10, job.isStateful());
                setBoolean(ps, 11, job.requestsRecovery());
            } else {
                ps.setString(8, null);
                ps.setString(9, null);
                setBoolean(ps, 10, false);
                setBoolean(ps, 11, false);
            }
            ps.setInt(12, trigger.getPriority());
            return ps.executeUpdate();
        } finally {
            closeStatement(ps);
        }
}

Insert a fired trigger.

 public int insertJobDetail(Connection conn,
    JobDetail job) throws IOException, SQLException 
{
        ByteArrayOutputStream baos = serializeJobData(job.getJobDataMap());
        PreparedStatement ps = null;
        int insertResult = 0;
        try {
            ps = conn.prepareStatement(rtp(INSERT_JOB_DETAIL));
            ps.setString(1, job.getName());
            ps.setString(2, job.getGroup());
            ps.setString(3, job.getDescription());
            ps.setString(4, job.getJobClass().getName());
            setBoolean(ps, 5, job.isDurable());
            setBoolean(ps, 6, job.isVolatile());
            setBoolean(ps, 7, job.isStateful());
            setBoolean(ps, 8, job.requestsRecovery());
            setBytes(ps, 9, baos);
            insertResult = ps.executeUpdate();
        } finally {
            closeStatement(ps);
        }
        if (insertResult  > 0) {
            String[] jobListeners = job.getJobListenerNames();
            for (int i = 0; jobListeners != null && i <  jobListeners.length; i++) {
                insertJobListener(conn, job, jobListeners[i]);
            }
        }
        return insertResult;
}

Insert the job detail record.

 public int insertJobListener(Connection conn,
    JobDetail job,
    String listener) throws SQLException 
{
        PreparedStatement ps = null;
        try {
            ps = conn.prepareStatement(rtp(INSERT_JOB_LISTENER));
            ps.setString(1, job.getName());
            ps.setString(2, job.getGroup());
            ps.setString(3, listener);
            return ps.executeUpdate();
        } finally {
            closeStatement(ps);
        }
}

Associate a listener with a job.

 public int insertPausedTriggerGroup(Connection conn,
    String groupName) throws SQLException 
{
        PreparedStatement ps = null;
        try {
            ps = conn.prepareStatement(rtp(INSERT_PAUSED_TRIGGER_GROUP));
            ps.setString(1, groupName);
            int rows = ps.executeUpdate();
            return rows;
        } finally {
            closeStatement(ps);
        }
}

 public int insertSchedulerState(Connection conn,
    String instanceId,
    long checkInTime,
    long interval) throws SQLException 
{
        PreparedStatement ps = null;
        try {
            ps = conn.prepareStatement(rtp(INSERT_SCHEDULER_STATE));
            ps.setString(1, instanceId);
            ps.setLong(2, checkInTime);
            ps.setLong(3, interval);
            return ps.executeUpdate();
        } finally {
            closeStatement(ps);
        }
}

 public int insertSimpleTrigger(Connection conn,
    SimpleTrigger trigger) throws SQLException 
{
        PreparedStatement ps = null;
        try {
            ps = conn.prepareStatement(rtp(INSERT_SIMPLE_TRIGGER));
            ps.setString(1, trigger.getName());
            ps.setString(2, trigger.getGroup());
            ps.setInt(3, trigger.getRepeatCount());
            ps.setBigDecimal(4, new BigDecimal(String.valueOf(trigger
                    .getRepeatInterval())));
            ps.setInt(5, trigger.getTimesTriggered());
            return ps.executeUpdate();
        } finally {
            closeStatement(ps);
        }
}

Insert the simple trigger data.

 public int insertTrigger(Connection conn,
    Trigger trigger,
    String state,
    JobDetail jobDetail) throws IOException, SQLException 
{
        ByteArrayOutputStream baos = null;
        if(trigger.getJobDataMap().size()  > 0) {
            baos = serializeJobData(trigger.getJobDataMap());
        }
        PreparedStatement ps = null;
        int insertResult = 0;
        try {
            ps = conn.prepareStatement(rtp(INSERT_TRIGGER));
            ps.setString(1, trigger.getName());
            ps.setString(2, trigger.getGroup());
            ps.setString(3, trigger.getJobName());
            ps.setString(4, trigger.getJobGroup());
            setBoolean(ps, 5, trigger.isVolatile());
            ps.setString(6, trigger.getDescription());
            ps.setBigDecimal(7, new BigDecimal(String.valueOf(trigger
                    .getNextFireTime().getTime())));
            long prevFireTime = -1;
            if (trigger.getPreviousFireTime() != null) {
                prevFireTime = trigger.getPreviousFireTime().getTime();
            }
            ps.setBigDecimal(8, new BigDecimal(String.valueOf(prevFireTime)));
            ps.setString(9, state);
            if (trigger.getClass() == SimpleTrigger.class) {
                ps.setString(10, TTYPE_SIMPLE);
            } else if (trigger.getClass() == CronTrigger.class) {
                ps.setString(10, TTYPE_CRON);
            } else {
                ps.setString(10, TTYPE_BLOB);
            }
            ps.setBigDecimal(11, new BigDecimal(String.valueOf(trigger
                    .getStartTime().getTime())));
            long endTime = 0;
            if (trigger.getEndTime() != null) {
                endTime = trigger.getEndTime().getTime();
            }
            ps.setBigDecimal(12, new BigDecimal(String.valueOf(endTime)));
            ps.setString(13, trigger.getCalendarName());
            ps.setInt(14, trigger.getMisfireInstruction());
            setBytes(ps, 15, baos);
            ps.setInt(16, trigger.getPriority());
            insertResult = ps.executeUpdate();
        } finally {
            closeStatement(ps);
        }
        if (insertResult  > 0) {
            String[] trigListeners = trigger.getTriggerListenerNames();
            for (int i = 0; trigListeners != null && i <  trigListeners.length; i++) {
                insertTriggerListener(conn, trigger, trigListeners[i]);
            }
        }
        return insertResult;
}

Insert the base trigger data.

 public int insertTriggerListener(Connection conn,
    Trigger trigger,
    String listener) throws SQLException 
{
        PreparedStatement ps = null;
        try {
            ps = conn.prepareStatement(rtp(INSERT_TRIGGER_LISTENER));
            ps.setString(1, trigger.getName());
            ps.setString(2, trigger.getGroup());
            ps.setString(3, listener);
            return ps.executeUpdate();
        } finally {
            closeStatement(ps);
        }
}

Associate a listener with the given trigger.

 public boolean isExistingTriggerGroup(Connection conn,
    String groupName) throws SQLException 
{
        PreparedStatement ps = null;
        ResultSet rs = null;
        try {
            ps = conn.prepareStatement(rtp(SELECT_NUM_TRIGGERS_IN_GROUP));
            ps.setString(1, groupName);
            rs = ps.executeQuery();
            if (!rs.next()) {
                return false;
            }
            return (rs.getInt(1)  > 0);
        } finally {
            closeResultSet(rs);
            closeStatement(ps);
        }
}

 public boolean isJobStateful(Connection conn,
    String jobName,
    String groupName) throws SQLException 
{
        PreparedStatement ps = null;
        ResultSet rs = null;
        try {
            ps = conn.prepareStatement(rtp(SELECT_JOB_STATEFUL));
            ps.setString(1, jobName);
            ps.setString(2, groupName);
            rs = ps.executeQuery();
            if (!rs.next()) { return false; }
            return getBoolean(rs, COL_IS_STATEFUL);
        } finally {
            closeResultSet(rs);
            closeStatement(ps);
        }
}

Check whether or not the given job is stateful.

 public boolean isTriggerGroupPaused(Connection conn,
    String groupName) throws SQLException 
{
        PreparedStatement ps = null;
        ResultSet rs = null;
        try {
            ps = conn.prepareStatement(rtp(SELECT_PAUSED_TRIGGER_GROUP));
            ps.setString(1, groupName);
            rs = ps.executeQuery();
            return rs.next();
        } finally {
            closeResultSet(rs);
            closeStatement(ps);
        }
}

 public boolean jobExists(Connection conn,
    String jobName,
    String groupName) throws SQLException 
{
        PreparedStatement ps = null;
        ResultSet rs = null;
        try {
            ps = conn.prepareStatement(rtp(SELECT_JOB_EXISTENCE));
            ps.setString(1, jobName);
            ps.setString(2, groupName);
            rs = ps.executeQuery();
            if (rs.next()) {
                return true;
            } else {
                return false;
            }
        } finally {
            closeResultSet(rs);
            closeStatement(ps);
        }
}

Check whether or not the given job exists.

 protected final String rtp(String query) 
{
        return Util.rtp(query, tablePrefix);
}

Replace the table prefix in a query by replacing any occurrences of "{0}" with the table prefix.

 public Calendar selectCalendar(Connection conn,
    String calendarName) throws IOException, ClassNotFoundException, SQLException 
{
        PreparedStatement ps = null;
        ResultSet rs = null;
        try {
            String selCal = rtp(SELECT_CALENDAR);
            ps = conn.prepareStatement(selCal);
            ps.setString(1, calendarName);
            rs = ps.executeQuery();
            Calendar cal = null;
            if (rs.next()) {
                cal = (Calendar) getObjectFromBlob(rs, COL_CALENDAR);
            }
            if (null == cal) {
                logger.warn("Couldn't find calendar with name '" + calendarName
                        + "'.");
            }
            return cal;
        } finally {
            closeResultSet(rs);
            closeStatement(ps);
        }
}

Select a calendar.

 public String[] selectCalendars(Connection conn) throws SQLException 
{
        PreparedStatement ps = null;
        ResultSet rs = null;
        try {
            ps = conn.prepareStatement(rtp(SELECT_CALENDARS));
            rs = ps.executeQuery();
            ArrayList list = new ArrayList();
            while (rs.next()) {
                list.add(rs.getString(1));
            }
            Object[] oArr = list.toArray();
            String[] sArr = new String[oArr.length];
            System.arraycopy(oArr, 0, sArr, 0, oArr.length);
            return sArr;
        } finally {
            closeResultSet(rs);
            closeStatement(ps);
        }
}

Select all of the stored calendars.

 public Set selectFiredTriggerInstanceNames(Connection conn) throws SQLException 
{
        PreparedStatement ps = null;
        ResultSet rs = null;
        try {
            Set instanceNames = new HashSet();
            ps = conn.prepareStatement(rtp(SELECT_FIRED_TRIGGER_INSTANCE_NAMES));
            rs = ps.executeQuery();
            while (rs.next()) {
                instanceNames.add(rs.getString(COL_INSTANCE_NAME));
            }
            return instanceNames;
        } finally {
            closeResultSet(rs);
            closeStatement(ps);
        }
}

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.)

 public List selectFiredTriggerRecords(Connection conn,
    String triggerName,
    String groupName) throws SQLException 
{
        PreparedStatement ps = null;
        ResultSet rs = null;
        try {
            List lst = new LinkedList();
            if (triggerName != null) {
                ps = conn.prepareStatement(rtp(SELECT_FIRED_TRIGGER));
                ps.setString(1, triggerName);
                ps.setString(2, groupName);
            } else {
                ps = conn.prepareStatement(rtp(SELECT_FIRED_TRIGGER_GROUP));
                ps.setString(1, groupName);
            }
            rs = ps.executeQuery();
            while (rs.next()) {
                FiredTriggerRecord rec = new FiredTriggerRecord();
                rec.setFireInstanceId(rs.getString(COL_ENTRY_ID));
                rec.setFireInstanceState(rs.getString(COL_ENTRY_STATE));
                rec.setFireTimestamp(rs.getLong(COL_FIRED_TIME));
                rec.setPriority(rs.getInt(COL_PRIORITY));
                rec.setSchedulerInstanceId(rs.getString(COL_INSTANCE_NAME));
                rec.setTriggerIsVolatile(getBoolean(rs, COL_IS_VOLATILE));
                rec.setTriggerKey(new Key(rs.getString(COL_TRIGGER_NAME), rs
                        .getString(COL_TRIGGER_GROUP)));
                if (!rec.getFireInstanceState().equals(STATE_ACQUIRED)) {
                    rec.setJobIsStateful(getBoolean(rs, COL_IS_STATEFUL));
                    rec.setJobRequestsRecovery(rs
                            .getBoolean(COL_REQUESTS_RECOVERY));
                    rec.setJobKey(new Key(rs.getString(COL_JOB_NAME), rs
                            .getString(COL_JOB_GROUP)));
                }
                lst.add(rec);
            }
            return lst;
        } finally {
            closeResultSet(rs);
            closeStatement(ps);
        }
}

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

 public List selectFiredTriggerRecordsByJob(Connection conn,
    String jobName,
    String groupName) throws SQLException 
{
        PreparedStatement ps = null;
        ResultSet rs = null;
        try {
            List lst = new LinkedList();
            if (jobName != null) {
                ps = conn.prepareStatement(rtp(SELECT_FIRED_TRIGGERS_OF_JOB));
                ps.setString(1, jobName);
                ps.setString(2, groupName);
            } else {
                ps = conn
                        .prepareStatement(rtp(SELECT_FIRED_TRIGGERS_OF_JOB_GROUP));
                ps.setString(1, groupName);
            }
            rs = ps.executeQuery();
            while (rs.next()) {
                FiredTriggerRecord rec = new FiredTriggerRecord();
                rec.setFireInstanceId(rs.getString(COL_ENTRY_ID));
                rec.setFireInstanceState(rs.getString(COL_ENTRY_STATE));
                rec.setFireTimestamp(rs.getLong(COL_FIRED_TIME));
                rec.setPriority(rs.getInt(COL_PRIORITY));
                rec.setSchedulerInstanceId(rs.getString(COL_INSTANCE_NAME));
                rec.setTriggerIsVolatile(getBoolean(rs, COL_IS_VOLATILE));
                rec.setTriggerKey(new Key(rs.getString(COL_TRIGGER_NAME), rs
                        .getString(COL_TRIGGER_GROUP)));
                if (!rec.getFireInstanceState().equals(STATE_ACQUIRED)) {
                    rec.setJobIsStateful(getBoolean(rs, COL_IS_STATEFUL));
                    rec.setJobRequestsRecovery(rs
                            .getBoolean(COL_REQUESTS_RECOVERY));
                    rec.setJobKey(new Key(rs.getString(COL_JOB_NAME), rs
                            .getString(COL_JOB_GROUP)));
                }
                lst.add(rec);
            }
            return lst;
        } finally {
            closeResultSet(rs);
            closeStatement(ps);
        }
}

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

 public List selectInstancesFiredTriggerRecords(Connection conn,
    String instanceName) throws SQLException 
{
        PreparedStatement ps = null;
        ResultSet rs = null;
        try {
            List lst = new LinkedList();
            ps = conn.prepareStatement(rtp(SELECT_INSTANCES_FIRED_TRIGGERS));
            ps.setString(1, instanceName);
            rs = ps.executeQuery();
            while (rs.next()) {
                FiredTriggerRecord rec = new FiredTriggerRecord();
                rec.setFireInstanceId(rs.getString(COL_ENTRY_ID));
                rec.setFireInstanceState(rs.getString(COL_ENTRY_STATE));
                rec.setFireTimestamp(rs.getLong(COL_FIRED_TIME));
                rec.setSchedulerInstanceId(rs.getString(COL_INSTANCE_NAME));
                rec.setTriggerIsVolatile(getBoolean(rs, COL_IS_VOLATILE));
                rec.setTriggerKey(new Key(rs.getString(COL_TRIGGER_NAME), rs
                        .getString(COL_TRIGGER_GROUP)));
                if (!rec.getFireInstanceState().equals(STATE_ACQUIRED)) {
                    rec.setJobIsStateful(getBoolean(rs, COL_IS_STATEFUL));
                    rec.setJobRequestsRecovery(rs
                            .getBoolean(COL_REQUESTS_RECOVERY));
                    rec.setJobKey(new Key(rs.getString(COL_JOB_NAME), rs
                            .getString(COL_JOB_GROUP)));
                }
                rec.setPriority(rs.getInt(COL_PRIORITY));
                lst.add(rec);
            }
            return lst;
        } finally {
            closeResultSet(rs);
            closeStatement(ps);
        }
}

 public JobDetail selectJobDetail(Connection conn,
    String jobName,
    String groupName,
    ClassLoadHelper loadHelper) throws IOException, ClassNotFoundException, SQLException 
{
        PreparedStatement ps = null;
        ResultSet rs = null;
        try {
            ps = conn.prepareStatement(rtp(SELECT_JOB_DETAIL));
            ps.setString(1, jobName);
            ps.setString(2, groupName);
            rs = ps.executeQuery();
            JobDetail job = null;
            if (rs.next()) {
                job = new JobDetail();
                job.setName(rs.getString(COL_JOB_NAME));
                job.setGroup(rs.getString(COL_JOB_GROUP));
                job.setDescription(rs.getString(COL_DESCRIPTION));
                job.setJobClass(loadHelper.loadClass(rs
                        .getString(COL_JOB_CLASS)));
                job.setDurability(getBoolean(rs, COL_IS_DURABLE));
                job.setVolatility(getBoolean(rs, COL_IS_VOLATILE));
                job.setRequestsRecovery(getBoolean(rs, COL_REQUESTS_RECOVERY));
                Map map = null;
                if (canUseProperties()) {
                    map = getMapFromProperties(rs);
                } else {
                    map = (Map) getObjectFromBlob(rs, COL_JOB_DATAMAP);
                }
                if (null != map) {
                    job.setJobDataMap(new JobDataMap(map));
                }
            }
            return job;
        } finally {
            closeResultSet(rs);
            closeStatement(ps);
        }
}

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

 public int selectJobExecutionCount(Connection conn,
    String jobName,
    String jobGroup) throws SQLException 
{
        PreparedStatement ps = null;
        ResultSet rs = null;
        try {
            ps = conn.prepareStatement(rtp(SELECT_JOB_EXECUTION_COUNT));
            ps.setString(1, jobName);
            ps.setString(2, jobGroup);
            rs = ps.executeQuery();
            return (rs.next()) ? rs.getInt(1) : 0;
        } finally {
            closeResultSet(rs);
            closeStatement(ps);
        }
}

 public JobDetail selectJobForTrigger(Connection conn,
    String triggerName,
    String groupName,
    ClassLoadHelper loadHelper) throws ClassNotFoundException, SQLException 
{
        PreparedStatement ps = null;
        ResultSet rs = null;
        try {
            ps = conn.prepareStatement(rtp(SELECT_JOB_FOR_TRIGGER));
            ps.setString(1, triggerName);
            ps.setString(2, groupName);
            rs = ps.executeQuery();
            if (rs.next()) {
                JobDetail job = new JobDetail();
                job.setName(rs.getString(1));
                job.setGroup(rs.getString(2));
                job.setDurability(getBoolean(rs, 3));
                job.setJobClass(loadHelper.loadClass(rs
                        .getString(4)));
                job.setRequestsRecovery(getBoolean(rs, 5));
                return job;
            } else {
                if (logger.isDebugEnabled()) {
                    logger.debug("No job for trigger '" + groupName + "."
                            + triggerName + "'.");
                }
                return null;
            }
        } finally {
            closeResultSet(rs);
            closeStatement(ps);
        }
}

Select the job to which the trigger is associated.

 public String[] selectJobGroups(Connection conn) throws SQLException 
{
        PreparedStatement ps = null;
        ResultSet rs = null;
        try {
            ps = conn.prepareStatement(rtp(SELECT_JOB_GROUPS));
            rs = ps.executeQuery();
            ArrayList list = new ArrayList();
            while (rs.next()) {
                list.add(rs.getString(1));
            }
            Object[] oArr = list.toArray();
            String[] sArr = new String[oArr.length];
            System.arraycopy(oArr, 0, sArr, 0, oArr.length);
            return sArr;
        } finally {
            closeResultSet(rs);
            closeStatement(ps);
        }
}

Select all of the job group names that are stored.

 public String[] selectJobListeners(Connection conn,
    String jobName,
    String groupName) throws SQLException 
{
        PreparedStatement ps = null;
        ResultSet rs = null;
        try {
            ArrayList list = new ArrayList();
            ps = conn.prepareStatement(rtp(SELECT_JOB_LISTENERS));
            ps.setString(1, jobName);
            ps.setString(2, groupName);
            rs = ps.executeQuery();
            while (rs.next()) {
                list.add(rs.getString(1));
            }
            Object[] oArr = list.toArray();
            String[] sArr = new String[oArr.length];
            System.arraycopy(oArr, 0, sArr, 0, oArr.length);
            return sArr;
        } finally {
            closeResultSet(rs);
            closeStatement(ps);
        }
}

Get all of the listeners for a given job.

 public String[] selectJobsInGroup(Connection conn,
    String groupName) throws SQLException 
{
        PreparedStatement ps = null;
        ResultSet rs = null;
        try {
            ps = conn.prepareStatement(rtp(SELECT_JOBS_IN_GROUP));
            ps.setString(1, groupName);
            rs = ps.executeQuery();
            ArrayList list = new ArrayList();
            while (rs.next()) {
                list.add(rs.getString(1));
            }
            Object[] oArr = list.toArray();
            String[] sArr = new String[oArr.length];
            System.arraycopy(oArr, 0, sArr, 0, oArr.length);
            return sArr;
        } finally {
            closeResultSet(rs);
            closeStatement(ps);
        }
}

Select all of the jobs contained in a given group.

 public Key[] selectMisfiredTriggers(Connection conn,
    long ts) throws SQLException 
{
        PreparedStatement ps = null;
        ResultSet rs = null;
        try {
            ps = conn.prepareStatement(rtp(SELECT_MISFIRED_TRIGGERS));
            ps.setBigDecimal(1, new BigDecimal(String.valueOf(ts)));
            rs = ps.executeQuery();
            ArrayList list = new ArrayList();
            while (rs.next()) {
                String triggerName = rs.getString(COL_TRIGGER_NAME);
                String groupName = rs.getString(COL_TRIGGER_GROUP);
                list.add(new Key(triggerName, groupName));
            }
            Object[] oArr = list.toArray();
            Key[] kArr = new Key[oArr.length];
            System.arraycopy(oArr, 0, kArr, 0, oArr.length);
            return kArr;
        } finally {
            closeResultSet(rs);
            closeStatement(ps);
        }
}

Get the names of all of the triggers that have misfired.

 public Key[] selectMisfiredTriggersInGroupInState(Connection conn,
    String groupName,
    String state,
    long ts) throws SQLException 
{
        PreparedStatement ps = null;
        ResultSet rs = null;
        try {
            ps = conn
                    .prepareStatement(rtp(SELECT_MISFIRED_TRIGGERS_IN_GROUP_IN_STATE));
            ps.setBigDecimal(1, new BigDecimal(String.valueOf(ts)));
            ps.setString(2, groupName);
            ps.setString(3, state);
            rs = ps.executeQuery();
            ArrayList list = new ArrayList();
            while (rs.next()) {
                String triggerName = rs.getString(COL_TRIGGER_NAME);
                list.add(new Key(triggerName, groupName));
            }
            Object[] oArr = list.toArray();
            Key[] kArr = new Key[oArr.length];
            System.arraycopy(oArr, 0, kArr, 0, oArr.length);
            return kArr;
        } finally {
            closeResultSet(rs);
            closeStatement(ps);
        }
}

Get the names of all of the triggers in the given group and state that have misfired.

 public Key[] selectMisfiredTriggersInState(Connection conn,
    String state,
    long ts) throws SQLException 
{
        PreparedStatement ps = null;
        ResultSet rs = null;
        try {
            ps = conn.prepareStatement(rtp(SELECT_MISFIRED_TRIGGERS_IN_STATE));
            ps.setBigDecimal(1, new BigDecimal(String.valueOf(ts)));
            ps.setString(2, state);
            rs = ps.executeQuery();
            ArrayList list = new ArrayList();
            while (rs.next()) {
                String triggerName = rs.getString(COL_TRIGGER_NAME);
                String groupName = rs.getString(COL_TRIGGER_GROUP);
                list.add(new Key(triggerName, groupName));
            }
            Object[] oArr = list.toArray();
            Key[] kArr = new Key[oArr.length];
            System.arraycopy(oArr, 0, kArr, 0, oArr.length);
            return kArr;
        } finally {
            closeResultSet(rs);
            closeStatement(ps);
        }
}

 public boolean selectMisfiredTriggersInStates(Connection conn,
    String state1,
    String state2,
    long ts,
    int count,
    List resultList) throws SQLException 
{
        PreparedStatement ps = null;
        ResultSet rs = null;
        try {
            ps = conn.prepareStatement(rtp(SELECT_MISFIRED_TRIGGERS_IN_STATES));
            ps.setBigDecimal(1, new BigDecimal(String.valueOf(ts)));
            ps.setString(2, state1);
            ps.setString(3, state2);
            rs = ps.executeQuery();
            boolean hasReachedLimit = false;
            while (rs.next() && (hasReachedLimit == false)) {
                if (resultList.size() == count) {
                    hasReachedLimit = true;
                } else {
                    String triggerName = rs.getString(COL_TRIGGER_NAME);
                    String groupName = rs.getString(COL_TRIGGER_GROUP);
                    resultList.add(new Key(triggerName, groupName));
                }
            }
            return hasReachedLimit;
        } finally {
            closeResultSet(rs);
            closeStatement(ps);
        }
}

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.

 public long selectNextFireTime(Connection conn) throws SQLException 
{
        PreparedStatement ps = null;
        ResultSet rs = null;
        try {
            ps = conn.prepareStatement(rtp(SELECT_NEXT_FIRE_TIME));
            ps.setString(1, STATE_WAITING);
            rs = ps.executeQuery();
            if (rs.next()) {
                return rs.getLong(ALIAS_COL_NEXT_FIRE_TIME);
            } else {
                return 0l;
            }
        } finally {
            closeResultSet(rs);
            closeStatement(ps);
        }
}

Select the next time that a trigger will be fired.

 public int selectNumCalendars(Connection conn) throws SQLException 
{
        PreparedStatement ps = null;
        ResultSet rs = null;
        try {
            int count = 0;
            ps = conn.prepareStatement(rtp(SELECT_NUM_CALENDARS));
            rs = ps.executeQuery();
            if (rs.next()) {
                count = rs.getInt(1);
            }
            return count;
        } finally {
            closeResultSet(rs);
            closeStatement(ps);
        }
}

Select the total number of calendars stored.

 public int selectNumJobs(Connection conn) throws SQLException 
{
        PreparedStatement ps = null;
        ResultSet rs = null;
        try {
            int count = 0;
            ps = conn.prepareStatement(rtp(SELECT_NUM_JOBS));
            rs = ps.executeQuery();
            if (rs.next()) {
                count = rs.getInt(1);
            }
            return count;
        } finally {
            closeResultSet(rs);
            closeStatement(ps);
        }
}

Select the total number of jobs stored.

 public int selectNumTriggers(Connection conn) throws SQLException 
{
        PreparedStatement ps = null;
        ResultSet rs = null;
        try {
            int count = 0;
            ps = conn.prepareStatement(rtp(SELECT_NUM_TRIGGERS));
            rs = ps.executeQuery();
            if (rs.next()) {
                count = rs.getInt(1);
            }
            return count;
        } finally {
            closeResultSet(rs);
            closeStatement(ps);
        }
}

Select the total number of triggers stored.

 public int selectNumTriggersForJob(Connection conn,
    String jobName,
    String groupName) throws SQLException 
{
        PreparedStatement ps = null;
        ResultSet rs = null;
        try {
            ps = conn.prepareStatement(rtp(SELECT_NUM_TRIGGERS_FOR_JOB));
            ps.setString(1, jobName);
            ps.setString(2, groupName);
            rs = ps.executeQuery();
            if (rs.next()) {
                return rs.getInt(1);
            } else {
                return 0;
            }
        } finally {
            closeResultSet(rs);
            closeStatement(ps);
        }
}

Select the number of triggers associated with a given job.

 public Set selectPausedTriggerGroups(Connection conn) throws SQLException 
{
        PreparedStatement ps = null;
        ResultSet rs = null;
        HashSet set = new HashSet();
        try {
            ps = conn.prepareStatement(rtp(SELECT_PAUSED_TRIGGER_GROUPS));
            rs = ps.executeQuery();
            while (rs.next()) {
                String groupName = rs.getString(COL_TRIGGER_GROUP);
                set.add(groupName);
            }
            return set;
        } finally {
            closeResultSet(rs);
            closeStatement(ps);
        }
}

 public List selectSchedulerStateRecords(Connection conn,
    String instanceId) throws SQLException 
{
        PreparedStatement ps = null;
        ResultSet rs = null;
        try {
            List lst = new LinkedList();
            if (instanceId != null) {
                ps = conn.prepareStatement(rtp(SELECT_SCHEDULER_STATE));
                ps.setString(1, instanceId);
            } else {
                ps = conn.prepareStatement(rtp(SELECT_SCHEDULER_STATES));
            }
            rs = ps.executeQuery();
            while (rs.next()) {
                SchedulerStateRecord rec = new SchedulerStateRecord();
                rec.setSchedulerInstanceId(rs.getString(COL_INSTANCE_NAME));
                rec.setCheckinTimestamp(rs.getLong(COL_LAST_CHECKIN_TIME));
                rec.setCheckinInterval(rs.getLong(COL_CHECKIN_INTERVAL));
                lst.add(rec);
            }
            return lst;
        } finally {
            closeResultSet(rs);
            closeStatement(ps);
        }
}

 public List selectStatefulJobsOfTriggerGroup(Connection conn,
    String groupName) throws SQLException 
{
        ArrayList jobList = new ArrayList();
        PreparedStatement ps = null;
        ResultSet rs = null;
        try {
            ps = conn
                    .prepareStatement(rtp(SELECT_STATEFUL_JOBS_OF_TRIGGER_GROUP));
            ps.setString(1, groupName);
            setBoolean(ps, 2, true);
            rs = ps.executeQuery();
            while (rs.next()) {
                jobList.add(new Key(rs.getString(COL_JOB_NAME), rs
                        .getString(COL_JOB_GROUP)));
            }
        } finally {
            closeResultSet(rs);
            closeStatement(ps);
        }
        return jobList;
}

 public Trigger selectTrigger(Connection conn,
    String triggerName,
    String groupName) throws IOException, ClassNotFoundException, SQLException 
{
        PreparedStatement ps = null;
        ResultSet rs = null;
        try {
            Trigger trigger = null;
            ps = conn.prepareStatement(rtp(SELECT_TRIGGER));
            ps.setString(1, triggerName);
            ps.setString(2, groupName);
            rs = ps.executeQuery();
            if (rs.next()) {
                String jobName = rs.getString(COL_JOB_NAME);
                String jobGroup = rs.getString(COL_JOB_GROUP);
                boolean volatility = getBoolean(rs, COL_IS_VOLATILE);
                String description = rs.getString(COL_DESCRIPTION);
                long nextFireTime = rs.getLong(COL_NEXT_FIRE_TIME);
                long prevFireTime = rs.getLong(COL_PREV_FIRE_TIME);
                String triggerType = rs.getString(COL_TRIGGER_TYPE);
                long startTime = rs.getLong(COL_START_TIME);
                long endTime = rs.getLong(COL_END_TIME);
                String calendarName = rs.getString(COL_CALENDAR_NAME);
                int misFireInstr = rs.getInt(COL_MISFIRE_INSTRUCTION);
                int priority = rs.getInt(COL_PRIORITY);
                Map map = null;
                if (canUseProperties()) {
                    map = getMapFromProperties(rs);
                } else {
                    map = (Map) getObjectFromBlob(rs, COL_JOB_DATAMAP);
                }
                Date nft = null;
                if (nextFireTime  > 0) {
                    nft = new Date(nextFireTime);
                }
                Date pft = null;
                if (prevFireTime  > 0) {
                    pft = new Date(prevFireTime);
                }
                Date startTimeD = new Date(startTime);
                Date endTimeD = null;
                if (endTime  > 0) {
                    endTimeD = new Date(endTime);
                }
                rs.close();
                ps.close();
                if (triggerType.equals(TTYPE_SIMPLE)) {
                    ps = conn.prepareStatement(rtp(SELECT_SIMPLE_TRIGGER));
                    ps.setString(1, triggerName);
                    ps.setString(2, groupName);
                    rs = ps.executeQuery();
                    if (rs.next()) {
                        int repeatCount = rs.getInt(COL_REPEAT_COUNT);
                        long repeatInterval = rs.getLong(COL_REPEAT_INTERVAL);
                        int timesTriggered = rs.getInt(COL_TIMES_TRIGGERED);
                        SimpleTrigger st = new SimpleTrigger(triggerName,
                                groupName, jobName, jobGroup, startTimeD,
                                endTimeD, repeatCount, repeatInterval);
                        st.setCalendarName(calendarName);
                        st.setMisfireInstruction(misFireInstr);
                        st.setTimesTriggered(timesTriggered);
                        st.setVolatility(volatility);
                        st.setNextFireTime(nft);
                        st.setPreviousFireTime(pft);
                        st.setDescription(description);
                        st.setPriority(priority);
                        if (null != map) {
                            st.setJobDataMap(new JobDataMap(map));
                        }
                        trigger = st;
                    }
                } else if (triggerType.equals(TTYPE_CRON)) {
                    ps = conn.prepareStatement(rtp(SELECT_CRON_TRIGGER));
                    ps.setString(1, triggerName);
                    ps.setString(2, groupName);
                    rs = ps.executeQuery();
                    if (rs.next()) {
                        String cronExpr = rs.getString(COL_CRON_EXPRESSION);
                        String timeZoneId = rs.getString(COL_TIME_ZONE_ID);
                        CronTrigger ct = null;
                        try {
                            TimeZone timeZone = null;
                            if (timeZoneId != null) {
                                timeZone = TimeZone.getTimeZone(timeZoneId);
                            }
                            ct = new CronTrigger(triggerName, groupName,
                                    jobName, jobGroup, startTimeD, endTimeD,
                                    cronExpr, timeZone);
                        } catch (Exception neverHappens) {
                            // expr must be valid, or it never would have
                            // gotten to the store...
                        }
                        if (null != ct) {
                            ct.setCalendarName(calendarName);
                            ct.setMisfireInstruction(misFireInstr);
                            ct.setVolatility(volatility);
                            ct.setNextFireTime(nft);
                            ct.setPreviousFireTime(pft);
                            ct.setDescription(description);
                            ct.setPriority(priority);
                            if (null != map) {
                                ct.setJobDataMap(new JobDataMap(map));
                            }
                            trigger = ct;
                        }
                    }
                } else if (triggerType.equals(TTYPE_BLOB)) {
                    ps = conn.prepareStatement(rtp(SELECT_BLOB_TRIGGER));
                    ps.setString(1, triggerName);
                    ps.setString(2, groupName);
                    rs = ps.executeQuery();
                    if (rs.next()) {
                        trigger = (Trigger) getObjectFromBlob(rs, COL_BLOB);
                    }
                } else {
                    throw new ClassNotFoundException("class for trigger type '"
                            + triggerType + "' not found.");
                }
            }
            return trigger;
        } finally {
            closeResultSet(rs);
            closeStatement(ps);
        }
}

Select a trigger.

 public Key selectTriggerForFireTime(Connection conn,
    long fireTime) throws SQLException 
{
        PreparedStatement ps = null;
        ResultSet rs = null;
        try {
            ps = conn.prepareStatement(rtp(SELECT_TRIGGER_FOR_FIRE_TIME));
            ps.setString(1, STATE_WAITING);
            ps.setBigDecimal(2, new BigDecimal(String.valueOf(fireTime)));
            rs = ps.executeQuery();
            if (rs.next()) {
                return new Key(rs.getString(COL_TRIGGER_NAME), rs
                        .getString(COL_TRIGGER_GROUP));
            } else {
                return null;
            }
        } finally {
            closeResultSet(rs);
            closeStatement(ps);
        }
}

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

 public String[] selectTriggerGroups(Connection conn) throws SQLException 
{
        PreparedStatement ps = null;
        ResultSet rs = null;
        try {
            ps = conn.prepareStatement(rtp(SELECT_TRIGGER_GROUPS));
            rs = ps.executeQuery();
            ArrayList list = new ArrayList();
            while (rs.next()) {
                list.add(rs.getString(1));
            }
            Object[] oArr = list.toArray();
            String[] sArr = new String[oArr.length];
            System.arraycopy(oArr, 0, sArr, 0, oArr.length);
            return sArr;
        } finally {
            closeResultSet(rs);
            closeStatement(ps);
        }
}

Select all of the trigger group names that are stored.

 public JobDataMap selectTriggerJobDataMap(Connection conn,
    String triggerName,
    String groupName) throws IOException, ClassNotFoundException, SQLException 
{
        
        PreparedStatement ps = null;
        ResultSet rs = null;
        try {
            Trigger trigger = null;
            ps = conn.prepareStatement(rtp(SELECT_TRIGGER_DATA));
            ps.setString(1, triggerName);
            ps.setString(2, groupName);
            rs = ps.executeQuery();
            if (rs.next()) {
                Map map = null;
                if (canUseProperties()) { 
                    map = getMapFromProperties(rs);
                } else {
                    map = (Map) getObjectFromBlob(rs, COL_JOB_DATAMAP);
                }
                rs.close();
                ps.close();
                if (null != map) {
                    return new JobDataMap(map);
                }
            }
        } finally {
            closeResultSet(rs);
            closeStatement(ps);
        }
        return new JobDataMap();
}

Select a trigger's JobDataMap.

 public String[] selectTriggerListeners(Connection conn,
    String triggerName,
    String groupName) throws SQLException 
{
        PreparedStatement ps = null;
        ResultSet rs = null;
        try {
            ps = conn.prepareStatement(rtp(SELECT_TRIGGER_LISTENERS));
            ps.setString(1, triggerName);
            ps.setString(2, groupName);
            rs = ps.executeQuery();
            ArrayList list = new ArrayList();
            while (rs.next()) {
                list.add(rs.getString(1));
            }
            Object[] oArr = list.toArray();
            String[] sArr = new String[oArr.length];
            System.arraycopy(oArr, 0, sArr, 0, oArr.length);
            return sArr;
        } finally {
            closeResultSet(rs);
            closeStatement(ps);
        }
}

Select the listeners associated with a given trigger.

 public Key[] selectTriggerNamesForJob(Connection conn,
    String jobName,
    String groupName) throws SQLException 
{
        PreparedStatement ps = null;
        ResultSet rs = null;
        try {
            ps = conn.prepareStatement(rtp(SELECT_TRIGGERS_FOR_JOB));
            ps.setString(1, jobName);
            ps.setString(2, groupName);
            rs = ps.executeQuery();
            ArrayList list = new ArrayList(10);
            while (rs.next()) {
                String trigName = rs.getString(COL_TRIGGER_NAME);
                String trigGroup = rs.getString(COL_TRIGGER_GROUP);
                list.add(new Key(trigName, trigGroup));
            }
            Object[] oArr = list.toArray();
            Key[] kArr = new Key[oArr.length];
            System.arraycopy(oArr, 0, kArr, 0, oArr.length);
            return kArr;
        } finally {
            closeResultSet(rs);
            closeStatement(ps);
        }
}

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

 public String selectTriggerState(Connection conn,
    String triggerName,
    String groupName) throws SQLException 
{
        PreparedStatement ps = null;
        ResultSet rs = null;
        try {
            String state = null;
            ps = conn.prepareStatement(rtp(SELECT_TRIGGER_STATE));
            ps.setString(1, triggerName);
            ps.setString(2, groupName);
            rs = ps.executeQuery();
            if (rs.next()) {
                state = rs.getString(COL_TRIGGER_STATE);
            } else {
                state = STATE_DELETED;
            }
            return state.intern();
        } finally {
            closeResultSet(rs);
            closeStatement(ps);
        }
}

Select a trigger' state value.

 public TriggerStatus selectTriggerStatus(Connection conn,
    String triggerName,
    String groupName) throws SQLException 
{
        PreparedStatement ps = null;
        ResultSet rs = null;
        try {
            TriggerStatus status = null;
            ps = conn.prepareStatement(rtp(SELECT_TRIGGER_STATUS));
            ps.setString(1, triggerName);
            ps.setString(2, groupName);
            rs = ps.executeQuery();
            if (rs.next()) {
                String state = rs.getString(COL_TRIGGER_STATE);
                long nextFireTime = rs.getLong(COL_NEXT_FIRE_TIME);
                String jobName = rs.getString(COL_JOB_NAME);
                String jobGroup = rs.getString(COL_JOB_GROUP);
                Date nft = null;
                if (nextFireTime  > 0) {
                    nft = new Date(nextFireTime);
                }
                status = new TriggerStatus(state, nft);
                status.setKey(new Key(triggerName, groupName));
                status.setJobKey(new Key(jobName, jobGroup));
            }
            return status;
        } finally {
            closeResultSet(rs);
            closeStatement(ps);
        }
}

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

 public Key selectTriggerToAcquire(Connection conn,
    long noLaterThan,
    long noEarlierThan) throws SQLException 
{
        PreparedStatement ps = null;
        ResultSet rs = null;
        try {
            ps = conn.prepareStatement(rtp(SELECT_NEXT_TRIGGER_TO_ACQUIRE));
            // Try to give jdbc driver a hint to hopefully not pull over 
            // more than the one row we actually need.
            ps.setFetchSize(1);
            ps.setMaxRows(1);
            ps.setString(1, STATE_WAITING);
            ps.setBigDecimal(2, new BigDecimal(String.valueOf(noLaterThan)));
            ps.setBigDecimal(3, new BigDecimal(String.valueOf(noEarlierThan)));
            rs = ps.executeQuery();
            if (rs.next()) {
                return new Key(
                        rs.getString(COL_TRIGGER_NAME),
                        rs.getString(COL_TRIGGER_GROUP));
            }
            return null;
        } finally {
            closeResultSet(rs);
            closeStatement(ps);
        }
}

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.

 public Trigger[] selectTriggersForCalendar(Connection conn,
    String calName) throws IOException, ClassNotFoundException, SQLException 
{
        ArrayList trigList = new ArrayList();
        PreparedStatement ps = null;
        ResultSet rs = null;
        try {
            ps = conn.prepareStatement(rtp(SELECT_TRIGGERS_FOR_CALENDAR));
            ps.setString(1, calName);
            rs = ps.executeQuery();
            while (rs.next()) {
                trigList.add(selectTrigger(conn,
                        rs.getString(COL_TRIGGER_NAME), rs
                                .getString(COL_TRIGGER_GROUP)));
            }
        } finally {
            closeResultSet(rs);
            closeStatement(ps);
        }
        return (Trigger[]) trigList.toArray(new Trigger[trigList.size()]);
}

 public Trigger[] selectTriggersForJob(Connection conn,
    String jobName,
    String groupName) throws IOException, ClassNotFoundException, SQLException 
{
        ArrayList trigList = new ArrayList();
        PreparedStatement ps = null;
        ResultSet rs = null;
        try {
            ps = conn.prepareStatement(rtp(SELECT_TRIGGERS_FOR_JOB));
            ps.setString(1, jobName);
            ps.setString(2, groupName);
            rs = ps.executeQuery();
            while (rs.next()) {
                Trigger t = selectTrigger(conn,
                        rs.getString(COL_TRIGGER_NAME), 
                        rs.getString(COL_TRIGGER_GROUP));
                if(t != null) {
                    trigList.add(t);
                }
            }
        } finally {
            closeResultSet(rs);
            closeStatement(ps);
        }
        return (Trigger[]) trigList.toArray(new Trigger[trigList.size()]);
}

Select the triggers for a job

 public Trigger[] selectTriggersForRecoveringJobs(Connection conn) throws ClassNotFoundException, IOException, SQLException 
{
        PreparedStatement ps = null;
        ResultSet rs = null;
        try {
            ps = conn
                    .prepareStatement(rtp(SELECT_INSTANCES_RECOVERABLE_FIRED_TRIGGERS));
            ps.setString(1, instanceId);
            setBoolean(ps, 2, true);
            rs = ps.executeQuery();
            long dumId = System.currentTimeMillis();
            ArrayList list = new ArrayList();
            while (rs.next()) {
                String jobName = rs.getString(COL_JOB_NAME);
                String jobGroup = rs.getString(COL_JOB_GROUP);
                String trigName = rs.getString(COL_TRIGGER_NAME);
                String trigGroup = rs.getString(COL_TRIGGER_GROUP);
                long firedTime = rs.getLong(COL_FIRED_TIME);
                int priority = rs.getInt(COL_PRIORITY);
                SimpleTrigger rcvryTrig = new SimpleTrigger("recover_"
                        + instanceId + "_" + String.valueOf(dumId++),
                        Scheduler.DEFAULT_RECOVERY_GROUP, new Date(firedTime));
                rcvryTrig.setJobName(jobName);
                rcvryTrig.setJobGroup(jobGroup);
                rcvryTrig.setPriority(priority);
                rcvryTrig
                        .setMisfireInstruction(SimpleTrigger.MISFIRE_INSTRUCTION_FIRE_NOW);
                JobDataMap jd = selectTriggerJobDataMap(conn, trigName, trigGroup);
                jd.put(Scheduler.FAILED_JOB_ORIGINAL_TRIGGER_NAME, trigName);
                jd.put(Scheduler.FAILED_JOB_ORIGINAL_TRIGGER_GROUP, trigGroup);
                jd.put(Scheduler.FAILED_JOB_ORIGINAL_TRIGGER_FIRETIME_IN_MILLISECONDS, String.valueOf(firedTime));
                rcvryTrig.setJobDataMap(jd);
                list.add(rcvryTrig);
            }
            Object[] oArr = list.toArray();
            Trigger[] tArr = new Trigger[oArr.length];
            System.arraycopy(oArr, 0, tArr, 0, oArr.length);
            return tArr;
        } finally {
            closeResultSet(rs);
            closeStatement(ps);
        }
}

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 org.quartz.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.

 public String[] selectTriggersInGroup(Connection conn,
    String groupName) throws SQLException 
{
        PreparedStatement ps = null;
        ResultSet rs = null;
        try {
            ps = conn.prepareStatement(rtp(SELECT_TRIGGERS_IN_GROUP));
            ps.setString(1, groupName);
            rs = ps.executeQuery();
            ArrayList list = new ArrayList();
            while (rs.next()) {
                list.add(rs.getString(1));
            }
            Object[] oArr = list.toArray();
            String[] sArr = new String[oArr.length];
            System.arraycopy(oArr, 0, sArr, 0, oArr.length);
            return sArr;
        } finally {
            closeResultSet(rs);
            closeStatement(ps);
        }
}

Select all of the triggers contained in a given group.

 public Key[] selectTriggersInState(Connection conn,
    String state) throws SQLException 
{
        PreparedStatement ps = null;
        ResultSet rs = null;
        try {
            ps = conn.prepareStatement(rtp(SELECT_TRIGGERS_IN_STATE));
            ps.setString(1, state);
            rs = ps.executeQuery();
            ArrayList list = new ArrayList();
            while (rs.next()) {
                list.add(new Key(rs.getString(1), rs.getString(2)));
            }
            Key[] sArr = (Key[]) list.toArray(new Key[list.size()]);
            return sArr;
        } finally {
            closeResultSet(rs);
            closeStatement(ps);
        }
}

Select all of the triggers in a given state.

 public Key[] selectVolatileJobs(Connection conn) throws SQLException 
{
        PreparedStatement ps = null;
        ResultSet rs = null;
        try {
            ps = conn.prepareStatement(rtp(SELECT_VOLATILE_JOBS));
            setBoolean(ps, 1, true);
            rs = ps.executeQuery();
            ArrayList list = new ArrayList();
            while (rs.next()) {
                String triggerName = rs.getString(COL_JOB_NAME);
                String groupName = rs.getString(COL_JOB_GROUP);
                list.add(new Key(triggerName, groupName));
            }
            Object[] oArr = list.toArray();
            Key[] kArr = new Key[oArr.length];
            System.arraycopy(oArr, 0, kArr, 0, oArr.length);
            return kArr;
        } finally {
            closeResultSet(rs);
            closeStatement(ps);
        }
}

 public Key[] selectVolatileTriggers(Connection conn) throws SQLException 
{
        PreparedStatement ps = null;
        ResultSet rs = null;
        try {
            ps = conn.prepareStatement(rtp(SELECT_VOLATILE_TRIGGERS));
            setBoolean(ps, 1, true);
            rs = ps.executeQuery();
            ArrayList list = new ArrayList();
            while (rs.next()) {
                String triggerName = rs.getString(COL_TRIGGER_NAME);
                String groupName = rs.getString(COL_TRIGGER_GROUP);
                list.add(new Key(triggerName, groupName));
            }
            Object[] oArr = list.toArray();
            Key[] kArr = new Key[oArr.length];
            System.arraycopy(oArr, 0, kArr, 0, oArr.length);
            return kArr;
        } finally {
            closeResultSet(rs);
            closeStatement(ps);
        }
}

 protected ByteArrayOutputStream serializeJobData(JobDataMap data) throws IOException 
{
        if (canUseProperties()) {
            return serializeProperties(data);
        }
        try {
            return serializeObject(data);
        } catch (NotSerializableException e) {
            throw new NotSerializableException(
                "Unable to serialize JobDataMap for insertion into " + 
                "database because the value of property '" + 
                getKeyOfNonSerializableValue(data) + 
                "' is not serializable: " + e.getMessage());
        }
}

Remove the transient data from and then create a serialized java.util.ByteArrayOutputStream version of a org.quartz.JobDataMap .

 protected ByteArrayOutputStream serializeObject(Object obj) throws IOException 
{
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        if (null != obj) {
            ObjectOutputStream out = new ObjectOutputStream(baos);
            out.writeObject(obj);
            out.flush();
        }
        return baos;
}

Create a serialized java.util.ByteArrayOutputStream version of an Object.

 protected  void setBoolean(PreparedStatement ps,
    int index,
    boolean val) throws SQLException 
{
        ps.setBoolean(index, val);
}

Sets the designated parameter to the given Java boolean value. This just wraps PreparedStatement#setBoolean(int, boolean) by default, but it can be overloaded by subclass delegates for databases that don't explicitly support the boolean type.

 protected  void setBytes(PreparedStatement ps,
    int index,
    ByteArrayOutputStream baos) throws SQLException 
{
        ps.setBytes(index, (baos == null) ? new byte[0] : baos.toByteArray());
}

Sets the designated parameter to the byte array of the given ByteArrayOutputStream. Will set parameter value to null if the ByteArrayOutputStream is null. This just wraps PreparedStatement#setBytes(int, byte[]) by default, but it can be overloaded by subclass delegates for databases that don't explicitly support storing bytes in this way.

 public boolean triggerExists(Connection conn,
    String triggerName,
    String groupName) throws SQLException 
{
        PreparedStatement ps = null;
        ResultSet rs = null;
        try {
            ps = conn.prepareStatement(rtp(SELECT_TRIGGER_EXISTENCE));
            ps.setString(1, triggerName);
            ps.setString(2, groupName);
            rs = ps.executeQuery();
            if (rs.next()) {
                return true;
            } else {
                return false;
            }
        } finally {
            closeResultSet(rs);
            closeStatement(ps);
        }
}

Check whether or not a trigger exists.

 public int updateBlobTrigger(Connection conn,
    Trigger trigger) throws IOException, SQLException 
{
        PreparedStatement ps = null;
        ByteArrayOutputStream os = null;
        try {
            // update the blob
            os = new ByteArrayOutputStream();
            ObjectOutputStream oos = new ObjectOutputStream(os);
            oos.writeObject(trigger);
            oos.close();
            byte[] buf = os.toByteArray();
            ByteArrayInputStream is = new ByteArrayInputStream(buf);
            ps = conn.prepareStatement(rtp(UPDATE_BLOB_TRIGGER));
            ps.setBinaryStream(1, is, buf.length);
            ps.setString(2, trigger.getName());
            ps.setString(3, trigger.getGroup());
            return ps.executeUpdate();
        } finally {
            closeStatement(ps);
            if (os != null) {
                os.close();
            }
        }
}

Update the blob trigger data.

 public int updateCalendar(Connection conn,
    String calendarName,
    Calendar calendar) throws IOException, SQLException 
{
        ByteArrayOutputStream baos = serializeObject(calendar);
        PreparedStatement ps = null;
        try {
            ps = conn.prepareStatement(rtp(UPDATE_CALENDAR));
            setBytes(ps, 1, baos);
            ps.setString(2, calendarName);
            return ps.executeUpdate();
        } finally {
            closeStatement(ps);
        }
}

Update a calendar.

 public int updateCronTrigger(Connection conn,
    CronTrigger trigger) throws SQLException 
{
        PreparedStatement ps = null;
        try {
            ps = conn.prepareStatement(rtp(UPDATE_CRON_TRIGGER));
            ps.setString(1, trigger.getCronExpression());
            ps.setString(2, trigger.getName());
            ps.setString(3, trigger.getGroup());
            return ps.executeUpdate();
        } finally {
            closeStatement(ps);
        }
}

Update the cron trigger data.

 public int updateJobData(Connection conn,
    JobDetail job) throws IOException, SQLException 
{
        ByteArrayOutputStream baos = serializeJobData(job.getJobDataMap());
        PreparedStatement ps = null;
        try {
            ps = conn.prepareStatement(rtp(UPDATE_JOB_DATA));
            setBytes(ps, 1, baos);
            ps.setString(2, job.getName());
            ps.setString(3, job.getGroup());
            return ps.executeUpdate();
        } finally {
            closeStatement(ps);
        }
}

Update the job data map for the given job.

 public int updateJobDetail(Connection conn,
    JobDetail job) throws IOException, SQLException 
{
        ByteArrayOutputStream baos = serializeJobData(job.getJobDataMap());
        PreparedStatement ps = null;
        int insertResult = 0;
        try {
            ps = conn.prepareStatement(rtp(UPDATE_JOB_DETAIL));
            ps.setString(1, job.getDescription());
            ps.setString(2, job.getJobClass().getName());
            setBoolean(ps, 3, job.isDurable());
            setBoolean(ps, 4, job.isVolatile());
            setBoolean(ps, 5, job.isStateful());
            setBoolean(ps, 6, job.requestsRecovery());
            setBytes(ps, 7, baos);
            ps.setString(8, job.getName());
            ps.setString(9, job.getGroup());
            insertResult = ps.executeUpdate();
        } finally {
            closeStatement(ps);
        }
        if (insertResult  > 0) {
            deleteJobListeners(conn, job.getName(), job.getGroup());
            String[] jobListeners = job.getJobListenerNames();
            for (int i = 0; jobListeners != null && i <  jobListeners.length; i++) {
                insertJobListener(conn, job, jobListeners[i]);
            }
        }
        return insertResult;
}

Update the job detail record.

 public int updateSchedulerState(Connection conn,
    String instanceId,
    long checkInTime) throws SQLException 
{
        PreparedStatement ps = null;
        try {
            ps = conn.prepareStatement(rtp(UPDATE_SCHEDULER_STATE));
            ps.setLong(1, checkInTime);
            ps.setString(2, instanceId);
            return ps.executeUpdate();
        } finally {
            closeStatement(ps);
        }
}

 public int updateSimpleTrigger(Connection conn,
    SimpleTrigger trigger) throws SQLException 
{
        PreparedStatement ps = null;
        try {
            ps = conn.prepareStatement(rtp(UPDATE_SIMPLE_TRIGGER));
            ps.setInt(1, trigger.getRepeatCount());
            ps.setBigDecimal(2, new BigDecimal(String.valueOf(trigger
                    .getRepeatInterval())));
            ps.setInt(3, trigger.getTimesTriggered());
            ps.setString(4, trigger.getName());
            ps.setString(5, trigger.getGroup());
            return ps.executeUpdate();
        } finally {
            closeStatement(ps);
        }
}

Update the simple trigger data.

 public int updateTrigger(Connection conn,
    Trigger trigger,
    String state,
    JobDetail jobDetail) throws IOException, SQLException 
{
        // save some clock cycles by unnecessarily writing job data blob ...
        boolean updateJobData = trigger.getJobDataMap().isDirty();
        ByteArrayOutputStream baos = null;
        if(updateJobData && trigger.getJobDataMap().size()  > 0) {
            baos = serializeJobData(trigger.getJobDataMap());
        }
        PreparedStatement ps = null;
        int insertResult = 0;
        try {
            if(updateJobData) {
                ps = conn.prepareStatement(rtp(UPDATE_TRIGGER));
            } else {
                ps = conn.prepareStatement(rtp(UPDATE_TRIGGER_SKIP_DATA));
            }
            ps.setString(1, trigger.getJobName());
            ps.setString(2, trigger.getJobGroup());
            setBoolean(ps, 3, trigger.isVolatile());
            ps.setString(4, trigger.getDescription());
            long nextFireTime = -1;
            if (trigger.getNextFireTime() != null) {
                nextFireTime = trigger.getNextFireTime().getTime();
            }
            ps.setBigDecimal(5, new BigDecimal(String.valueOf(nextFireTime)));
            long prevFireTime = -1;
            if (trigger.getPreviousFireTime() != null) {
                prevFireTime = trigger.getPreviousFireTime().getTime();
            }
            ps.setBigDecimal(6, new BigDecimal(String.valueOf(prevFireTime)));
            ps.setString(7, state);
            if (trigger.getClass() == SimpleTrigger.class) {
                //                updateSimpleTrigger(conn, (SimpleTrigger)trigger);
                ps.setString(8, TTYPE_SIMPLE);
            } else if (trigger.getClass() == CronTrigger.class) {
                //                updateCronTrigger(conn, (CronTrigger)trigger);
                ps.setString(8, TTYPE_CRON);
            } else {
                //                updateBlobTrigger(conn, trigger);
                ps.setString(8, TTYPE_BLOB);
            }
            ps.setBigDecimal(9, new BigDecimal(String.valueOf(trigger
                    .getStartTime().getTime())));
            long endTime = 0;
            if (trigger.getEndTime() != null) {
                endTime = trigger.getEndTime().getTime();
            }
            ps.setBigDecimal(10, new BigDecimal(String.valueOf(endTime)));
            ps.setString(11, trigger.getCalendarName());
            ps.setInt(12, trigger.getMisfireInstruction());
            ps.setInt(13, trigger.getPriority());
            if(updateJobData) {
                setBytes(ps, 14, baos);
                ps.setString(15, trigger.getName());
                ps.setString(16, trigger.getGroup());
            } else {
                ps.setString(14, trigger.getName());
                ps.setString(15, trigger.getGroup());
            }
            insertResult = ps.executeUpdate();
        } finally {
            closeStatement(ps);
        }
        if (insertResult  > 0) {
            deleteTriggerListeners(conn, trigger.getName(), trigger.getGroup());
            String[] trigListeners = trigger.getTriggerListenerNames();
            for (int i = 0; trigListeners != null && i <  trigListeners.length; i++) {
                insertTriggerListener(conn, trigger, trigListeners[i]);
            }
        }
        return insertResult;
}

Update the base trigger data.

 public int updateTriggerGroupStateFromOtherState(Connection conn,
    String groupName,
    String newState,
    String oldState) throws SQLException 
{
        PreparedStatement ps = null;
        try {
            ps = conn
                    .prepareStatement(rtp(UPDATE_TRIGGER_GROUP_STATE_FROM_STATE));
            ps.setString(1, newState);
            ps.setString(2, groupName);
            ps.setString(3, oldState);
            return ps.executeUpdate();
        } finally {
            closeStatement(ps);
        }
}

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

 public int updateTriggerGroupStateFromOtherStates(Connection conn,
    String groupName,
    String newState,
    String oldState1,
    String oldState2,
    String oldState3) throws SQLException 
{
        PreparedStatement ps = null;
        try {
            ps = conn
                    .prepareStatement(rtp(UPDATE_TRIGGER_GROUP_STATE_FROM_STATES));
            ps.setString(1, newState);
            ps.setString(2, groupName);
            ps.setString(3, oldState1);
            ps.setString(4, oldState2);
            ps.setString(5, oldState3);
            return ps.executeUpdate();
        } finally {
            closeStatement(ps);
        }
}

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

 public int updateTriggerState(Connection conn,
    String triggerName,
    String groupName,
    String state) throws SQLException 
{
        PreparedStatement ps = null;
        try {
            ps = conn.prepareStatement(rtp(UPDATE_TRIGGER_STATE));
            ps.setString(1, state);
            ps.setString(2, triggerName);
            ps.setString(3, groupName);
            return ps.executeUpdate();
        } finally {
            closeStatement(ps);
        }
}

Update the state for a given trigger.

 public int updateTriggerStateFromOtherState(Connection conn,
    String triggerName,
    String groupName,
    String newState,
    String oldState) throws SQLException 
{
        PreparedStatement ps = null;
        try {
            ps = conn.prepareStatement(rtp(UPDATE_TRIGGER_STATE_FROM_STATE));
            ps.setString(1, newState);
            ps.setString(2, triggerName);
            ps.setString(3, groupName);
            ps.setString(4, oldState);
            return ps.executeUpdate();
        } finally {
            closeStatement(ps);
        }
}

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

 public int updateTriggerStateFromOtherStates(Connection conn,
    String triggerName,
    String groupName,
    String newState,
    String oldState1,
    String oldState2,
    String oldState3) throws SQLException 
{
        PreparedStatement ps = null;
        try {
            ps = conn.prepareStatement(rtp(UPDATE_TRIGGER_STATE_FROM_STATES));
            ps.setString(1, newState);
            ps.setString(2, triggerName);
            ps.setString(3, groupName);
            ps.setString(4, oldState1);
            ps.setString(5, oldState2);
            ps.setString(6, oldState3);
            return ps.executeUpdate();
        } finally {
            closeStatement(ps);
        }
}

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

 public int updateTriggerStateFromOtherStatesBeforeTime(Connection conn,
    String newState,
    String oldState1,
    String oldState2,
    long time) throws SQLException 
{
        PreparedStatement ps = null;
        try {
            ps = conn
                    .prepareStatement(rtp(UPDATE_TRIGGER_STATE_FROM_OTHER_STATES_BEFORE_TIME));
            ps.setString(1, newState);
            ps.setString(2, oldState1);
            ps.setString(3, oldState2);
            ps.setLong(4, time);
            return ps.executeUpdate();
        } finally {
            closeStatement(ps);
        }
}

 public int updateTriggerStatesForJob(Connection conn,
    String jobName,
    String groupName,
    String state) throws SQLException 
{
        PreparedStatement ps = null;
        try {
            ps = conn.prepareStatement(rtp(UPDATE_JOB_TRIGGER_STATES));
            ps.setString(1, state);
            ps.setString(2, jobName);
            ps.setString(3, groupName);
            return ps.executeUpdate();
        } finally {
            closeStatement(ps);
        }
}

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

 public int updateTriggerStatesForJobFromOtherState(Connection conn,
    String jobName,
    String groupName,
    String state,
    String oldState) throws SQLException 
{
        PreparedStatement ps = null;
        try {
            ps = conn
                    .prepareStatement(rtp(UPDATE_JOB_TRIGGER_STATES_FROM_OTHER_STATE));
            ps.setString(1, state);
            ps.setString(2, jobName);
            ps.setString(3, groupName);
            ps.setString(4, oldState);
            return ps.executeUpdate();
        } finally {
            closeStatement(ps);
        }
}

 public int updateTriggerStatesFromOtherStates(Connection conn,
    String newState,
    String oldState1,
    String oldState2) throws SQLException 
{
        PreparedStatement ps = null;
        try {
            ps = conn
                    .prepareStatement(rtp(UPDATE_TRIGGER_STATES_FROM_OTHER_STATES));
            ps.setString(1, newState);
            ps.setString(2, oldState1);
            ps.setString(3, oldState2);
            return ps.executeUpdate();
        } finally {
            closeStatement(ps);
        }
}

Insert the job detail record.