Quartz提供兩種基本作業儲存型別。

第一種型別叫做RAMJobStore。

第二種型別叫做JDBC作業儲存。

在預設情況下Quartz將任務排程的執行資訊儲存在記憶體中，這種方法提供了最佳的效能，因為記憶體中資料訪問最快。不足之處是缺乏資料的永續性，當程式路途停止或系統崩潰時，所有執行的資訊都會丟失。

         比如我們希望安排一個執行100次的任務，如果執行到50次時系統崩潰了，系統重啟時任務的執行計數器將從0開始。在大多數實際的應用中，我們往往並不需要儲存任務排程的現場資料，因為很少需要規劃一個指定執行次數的任務。對於僅執行一次的任務來說，其執行條件資訊本身應該是已經持久化的業務資料（如鎖定到期解鎖任務，解鎖的時間應該是業務資料），當執行完成後，條件資訊也會相應改變。當然排程現場資訊不僅僅是記錄執行次數，還包括排程規則、JobDataMap中的資料等等。

        如果確實需要持久化任務排程資訊，Quartz允許你通過調整其屬性檔案，將這些資訊儲存到資料庫中。使用資料庫儲存任務排程資訊後，即使系統崩潰後重新啟動，任務的排程資訊將得到恢復。如前面所說的例子，執行50次崩潰後重新執行，計數器將從51開始計數。使用了資料庫儲存資訊的任務稱為持久化任務。

對比

 1:建立資料儲存表

因為需要把quartz的資料儲存到資料庫，所以要建立相關的資料庫。這個可以從下載到的quartz包裡面找到對應的sql指令碼，目前可以支援mysql，DB2，oracle等主流的資料庫，自己可以根據專案需要選擇合適的指令碼執行。

        我的專案是mysql的，就在資料中建立了一個quartzdb的database，因為我們用的是mysql，所以執行tables_mysql_innodb.sql指令碼建表。其中指令碼 檔案位於：quartz-2.2.3\docs\dbTables（根據你Quartz放置的目錄會不同）

2:裡面就是quartz框架需要的表,因為我們用到的是mysql資料庫,可以看驅動類StdJDBCDelegate.class:

quartz.properties:
# 驅動器方言 mysql驅動
org.quartz.jobStore.driverDelegateClass=org.quartz.impl.jdbcjobstore.StdJDBCDelegate

裡面也就是jdbc 連線資料庫 固定的sql語句、表

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package org.quartz.impl.jdbcjobstore;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.NotSerializableException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.math.BigDecimal;
import java.sql.Blob;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;
import java.util.Map.Entry;
import org.quartz.Calendar;
import org.quartz.Job;
import org.quartz.JobDataMap;
import org.quartz.JobDetail;
import org.quartz.JobKey;
import org.quartz.JobPersistenceException;
import org.quartz.TriggerBuilder;
import org.quartz.TriggerKey;
import org.quartz.impl.JobDetailImpl;
import org.quartz.impl.jdbcjobstore.TriggerPersistenceDelegate.TriggerPropertyBundle;
import org.quartz.impl.matchers.GroupMatcher;
import org.quartz.impl.matchers.StringMatcher.StringOperatorName;
import org.quartz.impl.triggers.SimpleTriggerImpl;
import org.quartz.spi.ClassLoadHelper;
import org.quartz.spi.OperableTrigger;
import org.slf4j.Logger;

public class StdJDBCDelegate implements DriverDelegate, StdJDBCConstants {
    protected Logger logger = null;
    protected String tablePrefix = "QRTZ_";
    protected String instanceId;
    protected String schedName;
    protected boolean useProperties;
    protected ClassLoadHelper classLoadHelper;
    protected List<TriggerPersistenceDelegate> triggerPersistenceDelegates = new LinkedList();
    private String schedNameLiteral = null;

    public StdJDBCDelegate() {
    }

    public void initialize(Logger logger, String tablePrefix, String schedName, String instanceId, ClassLoadHelper classLoadHelper, boolean useProperties, String initString) throws NoSuchDelegateException {
        this.logger = logger;
        this.tablePrefix = tablePrefix;
        this.schedName = schedName;
        this.instanceId = instanceId;
        this.useProperties = useProperties;
        this.classLoadHelper = classLoadHelper;
        this.addDefaultTriggerPersistenceDelegates();
        if (initString != null) {
            String[] settings = initString.split("\\|");
            String[] arr$ = settings;
            int len$ = settings.length;

            for(int i$ = 0; i$ < len$; ++i$) {
                String setting = arr$[i$];
                String[] parts = setting.split("=");
                String name = parts[0];
                if (parts.length != 1 && parts[1] != null && !parts[1].equals("")) {
                    if (!name.equals("triggerPersistenceDelegateClasses")) {
                        throw new NoSuchDelegateException("Unknown setting: '" + name + "'");
                    }

                    String[] trigDelegates = parts[1].split(",");
                    String[] arr$ = trigDelegates;
                    int len$ = trigDelegates.length;

                    for(int i$ = 0; i$ < len$; ++i$) {
                        String trigDelClassName = arr$[i$];

                        try {
                            Class<?> trigDelClass = classLoadHelper.loadClass(trigDelClassName);
                            this.addTriggerPersistenceDelegate((TriggerPersistenceDelegate)trigDelClass.newInstance());
                        } catch (Exception var21) {
                            throw new NoSuchDelegateException("Error instantiating TriggerPersistenceDelegate of type: " + trigDelClassName, var21);
                        }
                    }
                }
            }

        }
    }

    protected void addDefaultTriggerPersistenceDelegates() {
        this.addTriggerPersistenceDelegate(new SimpleTriggerPersistenceDelegate());
        this.addTriggerPersistenceDelegate(new CronTriggerPersistenceDelegate());
        this.addTriggerPersistenceDelegate(new CalendarIntervalTriggerPersistenceDelegate());
        this.addTriggerPersistenceDelegate(new DailyTimeIntervalTriggerPersistenceDelegate());
    }

    protected boolean canUseProperties() {
        return this.useProperties;
    }

    public void addTriggerPersistenceDelegate(TriggerPersistenceDelegate delegate) {
        this.logger.debug("Adding TriggerPersistenceDelegate of type: " + delegate.getClass().getCanonicalName());
        delegate.initialize(this.tablePrefix, this.schedName);
        this.triggerPersistenceDelegates.add(delegate);
    }

    public TriggerPersistenceDelegate findTriggerPersistenceDelegate(OperableTrigger trigger) {
        Iterator i$ = this.triggerPersistenceDelegates.iterator();

        TriggerPersistenceDelegate delegate;
        do {
            if (!i$.hasNext()) {
                return null;
            }

            delegate = (TriggerPersistenceDelegate)i$.next();
        } while(!delegate.canHandleTriggerType(trigger));

        return delegate;
    }

    public TriggerPersistenceDelegate findTriggerPersistenceDelegate(String discriminator) {
        Iterator i$ = this.triggerPersistenceDelegates.iterator();

        TriggerPersistenceDelegate delegate;
        do {
            if (!i$.hasNext()) {
                return null;
            }

            delegate = (TriggerPersistenceDelegate)i$.next();
        } while(!delegate.getHandledTriggerTypeDiscriminator().equals(discriminator));

        return delegate;
    }

    public int updateTriggerStatesFromOtherStates(Connection conn, String newState, String oldState1, String oldState2) throws SQLException {
        PreparedStatement ps = null;

        int var6;
        try {
            ps = conn.prepareStatement(this.rtp("UPDATE {0}TRIGGERS SET TRIGGER_STATE = ? WHERE SCHED_NAME = {1} AND (TRIGGER_STATE = ? OR TRIGGER_STATE = ?)"));
            ps.setString(1, newState);
            ps.setString(2, oldState1);
            ps.setString(3, oldState2);
            var6 = ps.executeUpdate();
        } finally {
            closeStatement(ps);
        }

        return var6;
    }

    public List<TriggerKey> selectMisfiredTriggers(Connection conn, long ts) throws SQLException {
        PreparedStatement ps = null;
        ResultSet rs = null;

        try {
            ps = conn.prepareStatement(this.rtp("SELECT * FROM {0}TRIGGERS WHERE SCHED_NAME = {1} AND NOT (MISFIRE_INSTR = -1) AND NEXT_FIRE_TIME < ? ORDER BY NEXT_FIRE_TIME ASC, PRIORITY DESC"));
            ps.setBigDecimal(1, new BigDecimal(String.valueOf(ts)));
            rs = ps.executeQuery();
            LinkedList list = new LinkedList();

            while(rs.next()) {
                String triggerName = rs.getString("TRIGGER_NAME");
                String groupName = rs.getString("TRIGGER_GROUP");
                list.add(TriggerKey.triggerKey(triggerName, groupName));
            }

            LinkedList var12 = list;
            return var12;
        } finally {
            closeResultSet(rs);
            closeStatement(ps);
        }
    }

    public List<TriggerKey> selectTriggersInState(Connection conn, String state) throws SQLException {
        PreparedStatement ps = null;
        ResultSet rs = null;

        try {
            ps = conn.prepareStatement(this.rtp("SELECT TRIGGER_NAME, TRIGGER_GROUP FROM {0}TRIGGERS WHERE SCHED_NAME = {1} AND TRIGGER_STATE = ?"));
            ps.setString(1, state);
            rs = ps.executeQuery();
            LinkedList list = new LinkedList();

            while(rs.next()) {
                list.add(TriggerKey.triggerKey(rs.getString(1), rs.getString(2)));
            }

            LinkedList var6 = list;
            return var6;
        } finally {
            closeResultSet(rs);
            closeStatement(ps);
        }
    }

    public List<TriggerKey> selectMisfiredTriggersInState(Connection conn, String state, long ts) throws SQLException {
        PreparedStatement ps = null;
        ResultSet rs = null;

        try {
            ps = conn.prepareStatement(this.rtp("SELECT TRIGGER_NAME, TRIGGER_GROUP FROM {0}TRIGGERS WHERE SCHED_NAME = {1} AND NOT (MISFIRE_INSTR = -1) AND NEXT_FIRE_TIME < ? AND TRIGGER_STATE = ? ORDER BY NEXT_FIRE_TIME ASC, PRIORITY DESC"));
            ps.setBigDecimal(1, new BigDecimal(String.valueOf(ts)));
            ps.setString(2, state);
            rs = ps.executeQuery();
            LinkedList list = new LinkedList();

            while(rs.next()) {
                String triggerName = rs.getString("TRIGGER_NAME");
                String groupName = rs.getString("TRIGGER_GROUP");
                list.add(TriggerKey.triggerKey(triggerName, groupName));
            }

            LinkedList var13 = list;
            return var13;
        } finally {
            closeResultSet(rs);
            closeStatement(ps);
        }
    }

    public boolean hasMisfiredTriggersInState(Connection conn, String state1, long ts, int count, List<TriggerKey> resultList) throws SQLException {
        PreparedStatement ps = null;
        ResultSet rs = null;

        try {
            ps = conn.prepareStatement(this.rtp("SELECT TRIGGER_NAME, TRIGGER_GROUP FROM {0}TRIGGERS WHERE SCHED_NAME = {1} AND NOT (MISFIRE_INSTR = -1) AND NEXT_FIRE_TIME < ? AND TRIGGER_STATE = ? ORDER BY NEXT_FIRE_TIME ASC, PRIORITY DESC"));
            ps.setBigDecimal(1, new BigDecimal(String.valueOf(ts)));
            ps.setString(2, state1);
            rs = ps.executeQuery();
            boolean hasReachedLimit = false;

            while(rs.next() && !hasReachedLimit) {
                if (resultList.size() == count) {
                    hasReachedLimit = true;
                } else {
                    String triggerName = rs.getString("TRIGGER_NAME");
                    String groupName = rs.getString("TRIGGER_GROUP");
                    resultList.add(TriggerKey.triggerKey(triggerName, groupName));
                }
            }

            boolean var15 = hasReachedLimit;
            return var15;
        } finally {
            closeResultSet(rs);
            closeStatement(ps);
        }
    }

    public int countMisfiredTriggersInState(Connection conn, String state1, long ts) throws SQLException {
        PreparedStatement ps = null;
        ResultSet rs = null;

        int var7;
        try {
            ps = conn.prepareStatement(this.rtp("SELECT COUNT(TRIGGER_NAME) FROM {0}TRIGGERS WHERE SCHED_NAME = {1} AND NOT (MISFIRE_INSTR = -1) AND NEXT_FIRE_TIME < ? AND TRIGGER_STATE = ?"));
            ps.setBigDecimal(1, new BigDecimal(String.valueOf(ts)));
            ps.setString(2, state1);
            rs = ps.executeQuery();
            if (!rs.next()) {
                throw new SQLException("No misfired trigger count returned.");
            }

            var7 = rs.getInt(1);
        } finally {
            closeResultSet(rs);
            closeStatement(ps);
        }

        return var7;
    }

    public List<TriggerKey> selectMisfiredTriggersInGroupInState(Connection conn, String groupName, String state, long ts) throws SQLException {
        PreparedStatement ps = null;
        ResultSet rs = null;

        try {
            ps = conn.prepareStatement(this.rtp("SELECT TRIGGER_NAME FROM {0}TRIGGERS WHERE SCHED_NAME = {1} AND NOT (MISFIRE_INSTR = -1) AND NEXT_FIRE_TIME < ? AND TRIGGER_GROUP = ? AND TRIGGER_STATE = ? ORDER BY NEXT_FIRE_TIME ASC, PRIORITY DESC"));
            ps.setBigDecimal(1, new BigDecimal(String.valueOf(ts)));
            ps.setString(2, groupName);
            ps.setString(3, state);
            rs = ps.executeQuery();
            LinkedList list = new LinkedList();

            while(rs.next()) {
                String triggerName = rs.getString("TRIGGER_NAME");
                list.add(TriggerKey.triggerKey(triggerName, groupName));
            }

            LinkedList var13 = list;
            return var13;
        } finally {
            closeResultSet(rs);
            closeStatement(ps);
        }
    }

    public List<OperableTrigger> selectTriggersForRecoveringJobs(Connection conn) throws SQLException, IOException, ClassNotFoundException {
        PreparedStatement ps = null;
        ResultSet rs = null;

        try {
            ps = conn.prepareStatement(this.rtp("SELECT * FROM {0}FIRED_TRIGGERS WHERE SCHED_NAME = {1} AND INSTANCE_NAME = ? AND REQUESTS_RECOVERY = ?"));
            ps.setString(1, this.instanceId);
            this.setBoolean(ps, 2, true);
            rs = ps.executeQuery();
            long dumId = System.currentTimeMillis();
            LinkedList list = new LinkedList();

            while(rs.next()) {
                String jobName = rs.getString("JOB_NAME");
                String jobGroup = rs.getString("JOB_GROUP");
                String trigName = rs.getString("TRIGGER_NAME");
                String trigGroup = rs.getString("TRIGGER_GROUP");
                long firedTime = rs.getLong("FIRED_TIME");
                long scheduledTime = rs.getLong("SCHED_TIME");
                int priority = rs.getInt("PRIORITY");
                SimpleTriggerImpl rcvryTrig = new SimpleTriggerImpl("recover_" + this.instanceId + "_" + dumId++, "RECOVERING_JOBS", new Date(scheduledTime));
                rcvryTrig.setJobName(jobName);
                rcvryTrig.setJobGroup(jobGroup);
                rcvryTrig.setPriority(priority);
                rcvryTrig.setMisfireInstruction(-1);
                JobDataMap jd = this.selectTriggerJobDataMap(conn, trigName, trigGroup);
                jd.put("QRTZ_FAILED_JOB_ORIG_TRIGGER_NAME", trigName);
                jd.put("QRTZ_FAILED_JOB_ORIG_TRIGGER_GROUP", trigGroup);
                jd.put("QRTZ_FAILED_JOB_ORIG_TRIGGER_FIRETIME_IN_MILLISECONDS_AS_STRING", String.valueOf(firedTime));
                jd.put("QRTZ_FAILED_JOB_ORIG_TRIGGER_SCHEDULED_FIRETIME_IN_MILLISECONDS_AS_STRING", String.valueOf(scheduledTime));
                rcvryTrig.setJobDataMap(jd);
                list.add(rcvryTrig);
            }

            LinkedList var21 = list;
            return var21;
        } finally {
            closeResultSet(rs);
            closeStatement(ps);
        }
    }

    public int deleteFiredTriggers(Connection conn) throws SQLException {
        PreparedStatement ps = null;

        int var3;
        try {
            ps = conn.prepareStatement(this.rtp("DELETE FROM {0}FIRED_TRIGGERS WHERE SCHED_NAME = {1}"));
            var3 = ps.executeUpdate();
        } finally {
            closeStatement(ps);
        }

        return var3;
    }

    public int deleteFiredTriggers(Connection conn, String theInstanceId) throws SQLException {
        PreparedStatement ps = null;

        int var4;
        try {
            ps = conn.prepareStatement(this.rtp("DELETE FROM {0}FIRED_TRIGGERS WHERE SCHED_NAME = {1} AND INSTANCE_NAME = ?"));
            ps.setString(1, theInstanceId);
            var4 = ps.executeUpdate();
        } finally {
            closeStatement(ps);
        }

        return var4;
    }

    public void clearData(Connection conn) throws SQLException {
        PreparedStatement ps = null;

        try {
            ps = conn.prepareStatement(this.rtp("DELETE FROM {0}SIMPLE_TRIGGERS  WHERE SCHED_NAME = {1}"));
            ps.executeUpdate();
            ps.close();
            ps = conn.prepareStatement(this.rtp("DELETE FROM {0}SIMPROP_TRIGGERS  WHERE SCHED_NAME = {1}"));
            ps.executeUpdate();
            ps.close();
            ps = conn.prepareStatement(this.rtp("DELETE FROM {0}CRON_TRIGGERS WHERE SCHED_NAME = {1}"));
            ps.executeUpdate();
            ps.close();
            ps = conn.prepareStatement(this.rtp("DELETE FROM {0}BLOB_TRIGGERS WHERE SCHED_NAME = {1}"));
            ps.executeUpdate();
            ps.close();
            ps = conn.prepareStatement(this.rtp("DELETE FROM {0}TRIGGERS WHERE SCHED_NAME = {1}"));
            ps.executeUpdate();
            ps.close();
            ps = conn.prepareStatement(this.rtp("DELETE FROM {0}JOB_DETAILS WHERE SCHED_NAME = {1}"));
            ps.executeUpdate();
            ps.close();
            ps = conn.prepareStatement(this.rtp("DELETE FROM {0}CALENDARS WHERE SCHED_NAME = {1}"));
            ps.executeUpdate();
            ps.close();
            ps = conn.prepareStatement(this.rtp("DELETE FROM {0}PAUSED_TRIGGER_GRPS WHERE SCHED_NAME = {1}"));
            ps.executeUpdate();
        } finally {
            closeStatement(ps);
        }

    }

    public int insertJobDetail(Connection conn, JobDetail job) throws IOException, SQLException {
        ByteArrayOutputStream baos = this.serializeJobData(job.getJobDataMap());
        PreparedStatement ps = null;
        boolean var5 = false;

        int insertResult;
        try {
            ps = conn.prepareStatement(this.rtp("INSERT INTO {0}JOB_DETAILS (SCHED_NAME, JOB_NAME, JOB_GROUP, DESCRIPTION, JOB_CLASS_NAME, IS_DURABLE, IS_NONCONCURRENT, IS_UPDATE_DATA, REQUESTS_RECOVERY, JOB_DATA)  VALUES({1}, ?, ?, ?, ?, ?, ?, ?, ?, ?)"));
            ps.setString(1, job.getKey().getName());
            ps.setString(2, job.getKey().getGroup());
            ps.setString(3, job.getDescription());
            ps.setString(4, job.getJobClass().getName());
            this.setBoolean(ps, 5, job.isDurable());
            this.setBoolean(ps, 6, job.isConcurrentExectionDisallowed());
            this.setBoolean(ps, 7, job.isPersistJobDataAfterExecution());
            this.setBoolean(ps, 8, job.requestsRecovery());
            this.setBytes(ps, 9, baos);
            insertResult = ps.executeUpdate();
        } finally {
            closeStatement(ps);
        }

        return insertResult;
    }

    public int updateJobDetail(Connection conn, JobDetail job) throws IOException, SQLException {
        ByteArrayOutputStream baos = this.serializeJobData(job.getJobDataMap());
        PreparedStatement ps = null;
        boolean var5 = false;

        int insertResult;
        try {
            ps = conn.prepareStatement(this.rtp("UPDATE {0}JOB_DETAILS SET DESCRIPTION = ?, JOB_CLASS_NAME = ?, IS_DURABLE = ?, IS_NONCONCURRENT = ?, IS_UPDATE_DATA = ?, REQUESTS_RECOVERY = ?, JOB_DATA = ?  WHERE SCHED_NAME = {1} AND JOB_NAME = ? AND JOB_GROUP = ?"));
            ps.setString(1, job.getDescription());
            ps.setString(2, job.getJobClass().getName());
            this.setBoolean(ps, 3, job.isDurable());
            this.setBoolean(ps, 4, job.isConcurrentExectionDisallowed());
            this.setBoolean(ps, 5, job.isPersistJobDataAfterExecution());
            this.setBoolean(ps, 6, job.requestsRecovery());
            this.setBytes(ps, 7, baos);
            ps.setString(8, job.getKey().getName());
            ps.setString(9, job.getKey().getGroup());
            insertResult = ps.executeUpdate();
        } finally {
            closeStatement(ps);
        }

        return insertResult;
    }

    public List<TriggerKey> selectTriggerKeysForJob(Connection conn, JobKey jobKey) throws SQLException {
        PreparedStatement ps = null;
        ResultSet rs = null;

        try {
            ps = conn.prepareStatement(this.rtp("SELECT TRIGGER_NAME, TRIGGER_GROUP FROM {0}TRIGGERS WHERE SCHED_NAME = {1} AND JOB_NAME = ? AND JOB_GROUP = ?"));
            ps.setString(1, jobKey.getName());
            ps.setString(2, jobKey.getGroup());
            rs = ps.executeQuery();
            LinkedList list = new LinkedList();

            while(rs.next()) {
                String trigName = rs.getString("TRIGGER_NAME");
                String trigGroup = rs.getString("TRIGGER_GROUP");
                list.add(TriggerKey.triggerKey(trigName, trigGroup));
            }

            LinkedList var11 = list;
            return var11;
        } finally {
            closeResultSet(rs);
            closeStatement(ps);
        }
    }

    public int deleteJobDetail(Connection conn, JobKey jobKey) throws SQLException {
        PreparedStatement ps = null;

        int var4;
        try {
            if (this.logger.isDebugEnabled()) {
                this.logger.debug("Deleting job: " + jobKey);
            }

            ps = conn.prepareStatement(this.rtp("DELETE FROM {0}JOB_DETAILS WHERE SCHED_NAME = {1} AND JOB_NAME = ? AND JOB_GROUP = ?"));
            ps.setString(1, jobKey.getName());
            ps.setString(2, jobKey.getGroup());
            var4 = ps.executeUpdate();
        } finally {
            closeStatement(ps);
        }

        return var4;
    }

    public boolean isJobNonConcurrent(Connection conn, JobKey jobKey) throws SQLException {
        PreparedStatement ps = null;
        ResultSet rs = null;

        boolean var5;
        try {
            ps = conn.prepareStatement(this.rtp("SELECT IS_NONCONCURRENT FROM {0}JOB_DETAILS WHERE SCHED_NAME = {1} AND JOB_NAME = ? AND JOB_GROUP = ?"));
            ps.setString(1, jobKey.getName());
            ps.setString(2, jobKey.getGroup());
            rs = ps.executeQuery();
            if (rs.next()) {
                var5 = this.getBoolean(rs, "IS_NONCONCURRENT");
                return var5;
            }

            var5 = false;
        } finally {
            closeResultSet(rs);
            closeStatement(ps);
        }

        return var5;
    }

    public boolean jobExists(Connection conn, JobKey jobKey) throws SQLException {
        PreparedStatement ps = null;
        ResultSet rs = null;

        boolean var5;
        try {
            ps = conn.prepareStatement(this.rtp("SELECT JOB_NAME FROM {0}JOB_DETAILS WHERE SCHED_NAME = {1} AND JOB_NAME = ? AND JOB_GROUP = ?"));
            ps.setString(1, jobKey.getName());
            ps.setString(2, jobKey.getGroup());
            rs = ps.executeQuery();
            if (!rs.next()) {
                var5 = false;
                return var5;
            }

            var5 = true;
        } finally {
            closeResultSet(rs);
            closeStatement(ps);
        }

        return var5;
    }

    public int updateJobData(Connection conn, JobDetail job) throws IOException, SQLException {
        ByteArrayOutputStream baos = this.serializeJobData(job.getJobDataMap());
        PreparedStatement ps = null;

        int var5;
        try {
            ps = conn.prepareStatement(this.rtp("UPDATE {0}JOB_DETAILS SET JOB_DATA = ?  WHERE SCHED_NAME = {1} AND JOB_NAME = ? AND JOB_GROUP = ?"));
            this.setBytes(ps, 1, baos);
            ps.setString(2, job.getKey().getName());
            ps.setString(3, job.getKey().getGroup());
            var5 = ps.executeUpdate();
        } finally {
            closeStatement(ps);
        }

        return var5;
    }

    public JobDetail selectJobDetail(Connection conn, JobKey jobKey, ClassLoadHelper loadHelper) throws ClassNotFoundException, IOException, SQLException {
        PreparedStatement ps = null;
        ResultSet rs = null;

        JobDetailImpl var11;
        try {
            ps = conn.prepareStatement(this.rtp("SELECT * FROM {0}JOB_DETAILS WHERE SCHED_NAME = {1} AND JOB_NAME = ? AND JOB_GROUP = ?"));
            ps.setString(1, jobKey.getName());
            ps.setString(2, jobKey.getGroup());
            rs = ps.executeQuery();
            JobDetailImpl job = null;
            if (rs.next()) {
                job = new JobDetailImpl();
                job.setName(rs.getString("JOB_NAME"));
                job.setGroup(rs.getString("JOB_GROUP"));
                job.setDescription(rs.getString("DESCRIPTION"));
                job.setJobClass(loadHelper.loadClass(rs.getString("JOB_CLASS_NAME"), Job.class));
                job.setDurability(this.getBoolean(rs, "IS_DURABLE"));
                job.setRequestsRecovery(this.getBoolean(rs, "REQUESTS_RECOVERY"));
                Map<?, ?> map = null;
                if (this.canUseProperties()) {
                    map = this.getMapFromProperties(rs);
                } else {
                    map = (Map)this.getObjectFromBlob(rs, "JOB_DATA");
                }

                if (null != map) {
                    job.setJobDataMap(new JobDataMap(map));
                }
            }

            var11 = job;
        } finally {
            closeResultSet(rs);
            closeStatement(ps);
        }

        return var11;
    }

    private Map<?, ?> getMapFromProperties(ResultSet rs) throws ClassNotFoundException, IOException, SQLException {
        InputStream is = (InputStream)this.getJobDataFromBlob(rs, "JOB_DATA");
        if (is == null) {
            return null;
        } else {
            Properties properties = new Properties();
            if (is != null) {
                try {
                    properties.load(is);
                } finally {
                    is.close();
                }
            }

            Map<?, ?> map = this.convertFromProperty(properties);
            return map;
        }
    }

    public int selectNumJobs(Connection conn) throws SQLException {
        PreparedStatement ps = null;
        ResultSet rs = null;

        int var5;
        try {
            int count = 0;
            ps = conn.prepareStatement(this.rtp("SELECT COUNT(JOB_NAME)  FROM {0}JOB_DETAILS WHERE SCHED_NAME = {1}"));
            rs = ps.executeQuery();
            if (rs.next()) {
                count = rs.getInt(1);
            }

            var5 = count;
        } finally {
            closeResultSet(rs);
            closeStatement(ps);
        }

        return var5;
    }

    public List<String> selectJobGroups(Connection conn) throws SQLException {
        PreparedStatement ps = null;
        ResultSet rs = null;

        try {
            ps = conn.prepareStatement(this.rtp("SELECT DISTINCT(JOB_GROUP) FROM {0}JOB_DETAILS WHERE SCHED_NAME = {1}"));
            rs = ps.executeQuery();
            LinkedList list = new LinkedList();

            while(rs.next()) {
                list.add(rs.getString(1));
            }

            LinkedList var5 = list;
            return var5;
        } finally {
            closeResultSet(rs);
            closeStatement(ps);
        }
    }

    public Set<JobKey> selectJobsInGroup(Connection conn, GroupMatcher<JobKey> matcher) throws SQLException {
        PreparedStatement ps = null;
        ResultSet rs = null;

        try {
            if (this.isMatcherEquals(matcher)) {
                ps = conn.prepareStatement(this.rtp("SELECT JOB_NAME, JOB_GROUP FROM {0}JOB_DETAILS WHERE SCHED_NAME = {1} AND JOB_GROUP = ?"));
                ps.setString(1, this.toSqlEqualsClause(matcher));
            } else {
                ps = conn.prepareStatement(this.rtp("SELECT JOB_NAME, JOB_GROUP FROM {0}JOB_DETAILS WHERE SCHED_NAME = {1} AND JOB_GROUP LIKE ?"));
                ps.setString(1, this.toSqlLikeClause(matcher));
            }

            rs = ps.executeQuery();
            LinkedList list = new LinkedList();

            while(rs.next()) {
                list.add(JobKey.jobKey(rs.getString(1), rs.getString(2)));
            }

            HashSet var6 = new HashSet(list);
            return var6;
        } finally {
            closeResultSet(rs);
            closeStatement(ps);
        }
    }

    protected boolean isMatcherEquals(GroupMatcher<?> matcher) {
        return matcher.getCompareWithOperator().equals(StringOperatorName.EQUALS);
    }

    protected String toSqlEqualsClause(GroupMatcher<?> matcher) {
        return matcher.getCompareToValue();
    }

    protected String toSqlLikeClause(GroupMatcher<?> matcher) {
        String groupName;
        switch(matcher.getCompareWithOperator()) {
        case EQUALS:
            groupName = matcher.getCompareToValue();
            break;
        case CONTAINS:
            groupName = "%" + matcher.getCompareToValue() + "%";
            break;
        case ENDS_WITH:
            groupName = "%" + matcher.getCompareToValue();
            break;
        case STARTS_WITH:
            groupName = matcher.getCompareToValue() + "%";
            break;
        case ANYTHING:
            groupName = "%";
            break;
        default:
            throw new UnsupportedOperationException("Don't know how to translate " + matcher.getCompareWithOperator() + " into SQL");
        }

        return groupName;
    }

    public int insertTrigger(Connection conn, OperableTrigger trigger, String state, JobDetail jobDetail) throws SQLException, IOException {
        ByteArrayOutputStream baos = null;
        if (trigger.getJobDataMap().size() > 0) {
            baos = this.serializeJobData(trigger.getJobDataMap());
        }

        PreparedStatement ps = null;
        boolean var7 = false;

        int insertResult;
        try {
            ps = conn.prepareStatement(this.rtp("INSERT INTO {0}TRIGGERS (SCHED_NAME, TRIGGER_NAME, TRIGGER_GROUP, JOB_NAME, JOB_GROUP, DESCRIPTION, NEXT_FIRE_TIME, PREV_FIRE_TIME, TRIGGER_STATE, TRIGGER_TYPE, START_TIME, END_TIME, CALENDAR_NAME, MISFIRE_INSTR, JOB_DATA, PRIORITY)  VALUES({1}, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)"));
            ps.setString(1, trigger.getKey().getName());
            ps.setString(2, trigger.getKey().getGroup());
            ps.setString(3, trigger.getJobKey().getName());
            ps.setString(4, trigger.getJobKey().getGroup());
            ps.setString(5, trigger.getDescription());
            if (trigger.getNextFireTime() != null) {
                ps.setBigDecimal(6, new BigDecimal(String.valueOf(trigger.getNextFireTime().getTime())));
            } else {
                ps.setBigDecimal(6, (BigDecimal)null);
            }

            long prevFireTime = -1L;
            if (trigger.getPreviousFireTime() != null) {
                prevFireTime = trigger.getPreviousFireTime().getTime();
            }

            ps.setBigDecimal(7, new BigDecimal(String.valueOf(prevFireTime)));
            ps.setString(8, state);
            TriggerPersistenceDelegate tDel = this.findTriggerPersistenceDelegate(trigger);
            String type = "BLOB";
            if (tDel != null) {
                type = tDel.getHandledTriggerTypeDiscriminator();
            }

            ps.setString(9, type);
            ps.setBigDecimal(10, new BigDecimal(String.valueOf(trigger.getStartTime().getTime())));
            long endTime = 0L;
            if (trigger.getEndTime() != null) {
                endTime = trigger.getEndTime().getTime();
            }

            ps.setBigDecimal(11, new BigDecimal(String.valueOf(endTime)));
            ps.setString(12, trigger.getCalendarName());
            ps.setInt(13, trigger.getMisfireInstruction());
            this.setBytes(ps, 14, baos);
            ps.setInt(15, trigger.getPriority());
            insertResult = ps.executeUpdate();
            if (tDel == null) {
                this.insertBlobTrigger(conn, trigger);
            } else {
                tDel.insertExtendedTriggerProperties(conn, trigger, state, jobDetail);
            }
        } finally {
            closeStatement(ps);
        }

        return insertResult;
    }

    public int insertBlobTrigger(Connection conn, OperableTrigger trigger) throws SQLException, IOException {
        PreparedStatement ps = null;
        ByteArrayOutputStream os = null;

        int var8;
        try {
            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(this.rtp("INSERT INTO {0}BLOB_TRIGGERS (SCHED_NAME, TRIGGER_NAME, TRIGGER_GROUP, BLOB_DATA)  VALUES({1}, ?, ?, ?)"));
            ps.setString(1, trigger.getKey().getName());
            ps.setString(2, trigger.getKey().getGroup());
            ps.setBinaryStream(3, is, buf.length);
            var8 = ps.executeUpdate();
        } finally {
            closeStatement(ps);
        }

        return var8;
    }

    public int updateTrigger(Connection conn, OperableTrigger trigger, String state, JobDetail jobDetail) throws SQLException, IOException {
        boolean updateJobData = trigger.getJobDataMap().isDirty();
        ByteArrayOutputStream baos = null;
        if (updateJobData && trigger.getJobDataMap().size() > 0) {
            baos = this.serializeJobData(trigger.getJobDataMap());
        }

        PreparedStatement ps = null;
        boolean var8 = false;

        int insertResult;
        try {
            if (updateJobData) {
                ps = conn.prepareStatement(this.rtp("UPDATE {0}TRIGGERS SET JOB_NAME = ?, JOB_GROUP = ?, DESCRIPTION = ?, NEXT_FIRE_TIME = ?, PREV_FIRE_TIME = ?, TRIGGER_STATE = ?, TRIGGER_TYPE = ?, START_TIME = ?, END_TIME = ?, CALENDAR_NAME = ?, MISFIRE_INSTR = ?, PRIORITY = ?, JOB_DATA = ? WHERE SCHED_NAME = {1} AND TRIGGER_NAME = ? AND TRIGGER_GROUP = ?"));
            } else {
                ps = conn.prepareStatement(this.rtp("UPDATE {0}TRIGGERS SET JOB_NAME = ?, JOB_GROUP = ?, DESCRIPTION = ?, NEXT_FIRE_TIME = ?, PREV_FIRE_TIME = ?, TRIGGER_STATE = ?, TRIGGER_TYPE = ?, START_TIME = ?, END_TIME = ?, CALENDAR_NAME = ?, MISFIRE_INSTR = ?, PRIORITY = ? WHERE SCHED_NAME = {1} AND TRIGGER_NAME = ? AND TRIGGER_GROUP = ?"));
            }

            ps.setString(1, trigger.getJobKey().getName());
            ps.setString(2, trigger.getJobKey().getGroup());
            ps.setString(3, trigger.getDescription());
            long nextFireTime = -1L;
            if (trigger.getNextFireTime() != null) {
                nextFireTime = trigger.getNextFireTime().getTime();
            }

            ps.setBigDecimal(4, new BigDecimal(String.valueOf(nextFireTime)));
            long prevFireTime = -1L;
            if (trigger.getPreviousFireTime() != null) {
                prevFireTime = trigger.getPreviousFireTime().getTime();
            }

            ps.setBigDecimal(5, new BigDecimal(String.valueOf(prevFireTime)));
            ps.setString(6, state);
            TriggerPersistenceDelegate tDel = this.findTriggerPersistenceDelegate(trigger);
            String type = "BLOB";
            if (tDel != null) {
                type = tDel.getHandledTriggerTypeDiscriminator();
            }

            ps.setString(7, type);
            ps.setBigDecimal(8, new BigDecimal(String.valueOf(trigger.getStartTime().getTime())));
            long endTime = 0L;
            if (trigger.getEndTime() != null) {
                endTime = trigger.getEndTime().getTime();
            }

            ps.setBigDecimal(9, new BigDecimal(String.valueOf(endTime)));
            ps.setString(10, trigger.getCalendarName());
            ps.setInt(11, trigger.getMisfireInstruction());
            ps.setInt(12, trigger.getPriority());
            if (updateJobData) {
                this.setBytes(ps, 13, baos);
                ps.setString(14, trigger.getKey().getName());
                ps.setString(15, trigger.getKey().getGroup());
            } else {
                ps.setString(13, trigger.getKey().getName());
                ps.setString(14, trigger.getKey().getGroup());
            }

            insertResult = ps.executeUpdate();
            if (tDel == null) {
                this.updateBlobTrigger(conn, trigger);
            } else {
                tDel.updateExtendedTriggerProperties(conn, trigger, state, jobDetail);
            }
        } finally {
            closeStatement(ps);
        }

        return insertResult;
    }

    public int updateBlobTrigger(Connection conn, OperableTrigger trigger) throws SQLException, IOException {
        PreparedStatement ps = null;
        ByteArrayOutputStream os = null;

        int var8;
        try {
            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(this.rtp("UPDATE {0}BLOB_TRIGGERS SET BLOB_DATA = ? WHERE SCHED_NAME = {1} AND TRIGGER_NAME = ? AND TRIGGER_GROUP = ?"));
            ps.setBinaryStream(1, is, buf.length);
            ps.setString(2, trigger.getKey().getName());
            ps.setString(3, trigger.getKey().getGroup());
            var8 = ps.executeUpdate();
        } finally {
            closeStatement(ps);
            if (os != null) {
                os.close();
            }

        }

        return var8;
    }

    public boolean triggerExists(Connection conn, TriggerKey triggerKey) throws SQLException {
        PreparedStatement ps = null;
        ResultSet rs = null;

        boolean var5;
        try {
            ps = conn.prepareStatement(this.rtp("SELECT TRIGGER_NAME FROM {0}TRIGGERS WHERE SCHED_NAME = {1} AND TRIGGER_NAME = ? AND TRIGGER_GROUP = ?"));
            ps.setString(1, triggerKey.getName());
            ps.setString(2, triggerKey.getGroup());
            rs = ps.executeQuery();
            if (!rs.next()) {
                var5 = false;
                return var5;
            }

            var5 = true;
        } finally {
            closeResultSet(rs);
            closeStatement(ps);
        }

        return var5;
    }

    public int updateTriggerState(Connection conn, TriggerKey triggerKey, String state) throws SQLException {
        PreparedStatement ps = null;

        int var5;
        try {
            ps = conn.prepareStatement(this.rtp("UPDATE {0}TRIGGERS SET TRIGGER_STATE = ? WHERE SCHED_NAME = {1} AND TRIGGER_NAME = ? AND TRIGGER_GROUP = ?"));
            ps.setString(1, state);
            ps.setString(2, triggerKey.getName());
            ps.setString(3, triggerKey.getGroup());
            var5 = ps.executeUpdate();
        } finally {
            closeStatement(ps);
        }

        return var5;
    }

    public int updateTriggerStateFromOtherStates(Connection conn, TriggerKey triggerKey, String newState, String oldState1, String oldState2, String oldState3) throws SQLException {
        PreparedStatement ps = null;

        int var8;
        try {
            ps = conn.prepareStatement(this.rtp("UPDATE {0}TRIGGERS SET TRIGGER_STATE = ? WHERE SCHED_NAME = {1} AND TRIGGER_NAME = ? AND TRIGGER_GROUP = ? AND (TRIGGER_STATE = ? OR TRIGGER_STATE = ? OR TRIGGER_STATE = ?)"));
            ps.setString(1, newState);
            ps.setString(2, triggerKey.getName());
            ps.setString(3, triggerKey.getGroup());
            ps.setString(4, oldState1);
            ps.setString(5, oldState2);
            ps.setString(6, oldState3);
            var8 = ps.executeUpdate();
        } finally {
            closeStatement(ps);
        }

        return var8;
    }

    public int updateTriggerGroupStateFromOtherStates(Connection conn, GroupMatcher<TriggerKey> matcher, String newState, String oldState1, String oldState2, String oldState3) throws SQLException {
        PreparedStatement ps = null;

        int var8;
        try {
            ps = conn.prepareStatement(this.rtp("UPDATE {0}TRIGGERS SET TRIGGER_STATE = ? WHERE SCHED_NAME = {1} AND TRIGGER_GROUP LIKE ? AND (TRIGGER_STATE = ? OR TRIGGER_STATE = ? OR TRIGGER_STATE = ?)"));
            ps.setString(1, newState);
            ps.setString(2, this.toSqlLikeClause(matcher));
            ps.setString(3, oldState1);
            ps.setString(4, oldState2);
            ps.setString(5, oldState3);
            var8 = ps.executeUpdate();
        } finally {
            closeStatement(ps);
        }

        return var8;
    }

    public int updateTriggerStateFromOtherState(Connection conn, TriggerKey triggerKey, String newState, String oldState) throws SQLException {
        PreparedStatement ps = null;

        int var6;
        try {
            ps = conn.prepareStatement(this.rtp("UPDATE {0}TRIGGERS SET TRIGGER_STATE = ? WHERE SCHED_NAME = {1} AND TRIGGER_NAME = ? AND TRIGGER_GROUP = ? AND TRIGGER_STATE = ?"));
            ps.setString(1, newState);
            ps.setString(2, triggerKey.getName());
            ps.setString(3, triggerKey.getGroup());
            ps.setString(4, oldState);
            var6 = ps.executeUpdate();
        } finally {
            closeStatement(ps);
        }

        return var6;
    }

    public int updateTriggerGroupStateFromOtherState(Connection conn, GroupMatcher<TriggerKey> matcher, String newState, String oldState) throws SQLException {
        PreparedStatement ps = null;

        int var6;
        try {
            ps = conn.prepareStatement(this.rtp("UPDATE {0}TRIGGERS SET TRIGGER_STATE = ? WHERE SCHED_NAME = {1} AND TRIGGER_GROUP LIKE ? AND TRIGGER_STATE = ?"));
            ps.setString(1, newState);
            ps.setString(2, this.toSqlLikeClause(matcher));
            ps.setString(3, oldState);
            var6 = ps.executeUpdate();
        } finally {
            closeStatement(ps);
        }

        return var6;
    }

    public int updateTriggerStatesForJob(Connection conn, JobKey jobKey, String state) throws SQLException {
        PreparedStatement ps = null;

        int var5;
        try {
            ps = conn.prepareStatement(this.rtp("UPDATE {0}TRIGGERS SET TRIGGER_STATE = ? WHERE SCHED_NAME = {1} AND JOB_NAME = ? AND JOB_GROUP = ?"));
            ps.setString(1, state);
            ps.setString(2, jobKey.getName());
            ps.setString(3, jobKey.getGroup());
            var5 = ps.executeUpdate();
        } finally {
            closeStatement(ps);
        }

        return var5;
    }

    public int updateTriggerStatesForJobFromOtherState(Connection conn, JobKey jobKey, String state, String oldState) throws SQLException {
        PreparedStatement ps = null;

        int var6;
        try {
            ps = conn.prepareStatement(this.rtp("UPDATE {0}TRIGGERS SET TRIGGER_STATE = ? WHERE SCHED_NAME = {1} AND JOB_NAME = ? AND JOB_GROUP = ? AND TRIGGER_STATE = ?"));
            ps.setString(1, state);
            ps.setString(2, jobKey.getName());
            ps.setString(3, jobKey.getGroup());
            ps.setString(4, oldState);
            var6 = ps.executeUpdate();
        } finally {
            closeStatement(ps);
        }

        return var6;
    }

    public int deleteBlobTrigger(Connection conn, TriggerKey triggerKey) throws SQLException {
        PreparedStatement ps = null;

        int var4;
        try {
            ps = conn.prepareStatement(this.rtp("DELETE FROM {0}BLOB_TRIGGERS WHERE SCHED_NAME = {1} AND TRIGGER_NAME = ? AND TRIGGER_GROUP = ?"));
            ps.setString(1, triggerKey.getName());
            ps.setString(2, triggerKey.getGroup());
            var4 = ps.executeUpdate();
        } finally {
            closeStatement(ps);
        }

        return var4;
    }

    public int deleteTrigger(Connection conn, TriggerKey triggerKey) throws SQLException {
        PreparedStatement ps = null;
        this.deleteTriggerExtension(conn, triggerKey);

        int var4;
        try {
            ps = conn.prepareStatement(this.rtp("DELETE FROM {0}TRIGGERS WHERE SCHED_NAME = {1} AND TRIGGER_NAME = ? AND TRIGGER_GROUP = ?"));
            ps.setString(1, triggerKey.getName());
            ps.setString(2, triggerKey.getGroup());
            var4 = ps.executeUpdate();
        } finally {
            closeStatement(ps);
        }

        return var4;
    }

    protected void deleteTriggerExtension(Connection conn, TriggerKey triggerKey) throws SQLException {
        Iterator i$ = this.triggerPersistenceDelegates.iterator();

        TriggerPersistenceDelegate tDel;
        do {
            if (!i$.hasNext()) {
                this.deleteBlobTrigger(conn, triggerKey);
                return;
            }

            tDel = (TriggerPersistenceDelegate)i$.next();
        } while(tDel.deleteExtendedTriggerProperties(conn, triggerKey) <= 0);

    }

    public int selectNumTriggersForJob(Connection conn, JobKey jobKey) throws SQLException {
        PreparedStatement ps = null;
        ResultSet rs = null;

        int var5;
        try {
            ps = conn.prepareStatement(this.rtp("SELECT COUNT(TRIGGER_NAME) FROM {0}TRIGGERS WHERE SCHED_NAME = {1} AND JOB_NAME = ? AND JOB_GROUP = ?"));
            ps.setString(1, jobKey.getName());
            ps.setString(2, jobKey.getGroup());
            rs = ps.executeQuery();
            if (!rs.next()) {
                byte var9 = 0;
                return var9;
            }

            var5 = rs.getInt(1);
        } finally {
            closeResultSet(rs);
            closeStatement(ps);
        }

        return var5;
    }

    public JobDetail selectJobForTrigger(Connection conn, ClassLoadHelper loadHelper, TriggerKey triggerKey) throws ClassNotFoundException, SQLException {
        return this.selectJobForTrigger(conn, loadHelper, triggerKey, true);
    }

    public JobDetail selectJobForTrigger(Connection conn, ClassLoadHelper loadHelper, TriggerKey triggerKey, boolean loadJobClass) throws ClassNotFoundException, SQLException {
        PreparedStatement ps = null;
        ResultSet rs = null;

        JobDetailImpl var8;
        try {
            ps = conn.prepareStatement(this.rtp("SELECT J.JOB_NAME, J.JOB_GROUP, J.IS_DURABLE, J.JOB_CLASS_NAME, J.REQUESTS_RECOVERY FROM {0}TRIGGERS T, {0}JOB_DETAILS J WHERE T.SCHED_NAME = {1} AND J.SCHED_NAME = {1} AND T.TRIGGER_NAME = ? AND T.TRIGGER_GROUP = ? AND T.JOB_NAME = J.JOB_NAME AND T.JOB_GROUP = J.JOB_GROUP"));
            ps.setString(1, triggerKey.getName());
            ps.setString(2, triggerKey.getGroup());
            rs = ps.executeQuery();
            JobDetailImpl job;
            if (!rs.next()) {
                if (this.logger.isDebugEnabled()) {
                    this.logger.debug("No job for trigger '" + triggerKey + "'.");
                }

                job = null;
                return job;
            }

            job = new JobDetailImpl();
            job.setName(rs.getString(1));
            job.setGroup(rs.getString(2));
            job.setDurability(this.getBoolean(rs, 3));
            if (loadJobClass) {
                job.setJobClass(loadHelper.loadClass(rs.getString(4), Job.class));
            }

            job.setRequestsRecovery(this.getBoolean(rs, 5));
            var8 = job;
        } finally {
            closeResultSet(rs);
            closeStatement(ps);
        }

        return var8;
    }

    public List<OperableTrigger> selectTriggersForJob(Connection conn, JobKey jobKey) throws SQLException, ClassNotFoundException, IOException, JobPersistenceException {
        LinkedList<OperableTrigger> trigList = new LinkedList();
        PreparedStatement ps = null;
        ResultSet rs = null;

        try {
            ps = conn.prepareStatement(this.rtp("SELECT TRIGGER_NAME, TRIGGER_GROUP FROM {0}TRIGGERS WHERE SCHED_NAME = {1} AND JOB_NAME = ? AND JOB_GROUP = ?"));
            ps.setString(1, jobKey.getName());
            ps.setString(2, jobKey.getGroup());
            rs = ps.executeQuery();

            while(rs.next()) {
                OperableTrigger t = this.selectTrigger(conn, TriggerKey.triggerKey(rs.getString("TRIGGER_NAME"), rs.getString("TRIGGER_GROUP")));
                if (t != null) {
                    trigList.add(t);
                }
            }
        } finally {
            closeResultSet(rs);
            closeStatement(ps);
        }

        return trigList;
    }

    public List<OperableTrigger> selectTriggersForCalendar(Connection conn, String calName) throws SQLException, ClassNotFoundException, IOException, JobPersistenceException {
        LinkedList<OperableTrigger> trigList = new LinkedList();
        PreparedStatement ps = null;
        ResultSet rs = null;

        try {
            ps = conn.prepareStatement(this.rtp("SELECT TRIGGER_NAME, TRIGGER_GROUP FROM {0}TRIGGERS WHERE SCHED_NAME = {1} AND CALENDAR_NAME = ?"));
            ps.setString(1, calName);
            rs = ps.executeQuery();

            while(rs.next()) {
                trigList.add(this.selectTrigger(conn, TriggerKey.triggerKey(rs.getString("TRIGGER_NAME"), rs.getString("TRIGGER_GROUP"))));
            }
        } finally {
            closeResultSet(rs);
            closeStatement(ps);
        }

        return trigList;
    }

    public OperableTrigger selectTrigger(Connection conn, TriggerKey triggerKey) throws SQLException, ClassNotFoundException, IOException, JobPersistenceException {
        PreparedStatement ps = null;
        ResultSet rs = null;

        try {
            OperableTrigger trigger = null;
            ps = conn.prepareStatement(this.rtp("SELECT * FROM {0}TRIGGERS WHERE SCHED_NAME = {1} AND TRIGGER_NAME = ? AND TRIGGER_GROUP = ?"));
            ps.setString(1, triggerKey.getName());
            ps.setString(2, triggerKey.getGroup());
            rs = ps.executeQuery();
            if (rs.next()) {
                String jobName = rs.getString("JOB_NAME");
                String jobGroup = rs.getString("JOB_GROUP");
                String description = rs.getString("DESCRIPTION");
                long nextFireTime = rs.getLong("NEXT_FIRE_TIME");
                long prevFireTime = rs.getLong("PREV_FIRE_TIME");
                String triggerType = rs.getString("TRIGGER_TYPE");
                long startTime = rs.getLong("START_TIME");
                long endTime = rs.getLong("END_TIME");
                String calendarName = rs.getString("CALENDAR_NAME");
                int misFireInstr = rs.getInt("MISFIRE_INSTR");
                int priority = rs.getInt("PRIORITY");
                Map<?, ?> map = null;
                if (this.canUseProperties()) {
                    map = this.getMapFromProperties(rs);
                } else {
                    map = (Map)this.getObjectFromBlob(rs, "JOB_DATA");
                }

                Date nft = null;
                if (nextFireTime > 0L) {
                    nft = new Date(nextFireTime);
                }

                Date pft = null;
                if (prevFireTime > 0L) {
                    pft = new Date(prevFireTime);
                }

                Date startTimeD = new Date(startTime);
                Date endTimeD = null;
                if (endTime > 0L) {
                    endTimeD = new Date(endTime);
                }

                if (triggerType.equals("BLOB")) {
                    rs.close();
                    rs = null;
                    ps.close();
                    ps = null;
                    ps = conn.prepareStatement(this.rtp("SELECT * FROM {0}BLOB_TRIGGERS WHERE SCHED_NAME = {1} AND TRIGGER_NAME = ? AND TRIGGER_GROUP = ?"));
                    ps.setString(1, triggerKey.getName());
                    ps.setString(2, triggerKey.getGroup());
                    rs = ps.executeQuery();
                    if (rs.next()) {
                        trigger = (OperableTrigger)this.getObjectFromBlob(rs, "BLOB_DATA");
                    }
                } else {
                    TriggerPersistenceDelegate tDel = this.findTriggerPersistenceDelegate(triggerType);
                    if (tDel == null) {
                        throw new JobPersistenceException("No TriggerPersistenceDelegate for trigger discriminator type: " + triggerType);
                    }

                    TriggerPropertyBundle triggerProps = null;

                    try {
                        triggerProps = tDel.loadExtendedTriggerProperties(conn, triggerKey);
                    } catch (IllegalStateException var33) {
                        if (this.isTriggerStillPresent(ps)) {
                            throw var33;
                        }

                        Object var29 = null;
                        return (OperableTrigger)var29;
                    }

                    TriggerBuilder<?> tb = TriggerBuilder.newTrigger().withDescription(description).withPriority(priority).startAt(startTimeD).endAt(endTimeD).withIdentity(triggerKey).modifiedByCalendar(calendarName).withSchedule(triggerProps.getScheduleBuilder()).forJob(JobKey.jobKey(jobName, jobGroup));
                    if (null != map) {
                        tb.usingJobData(new JobDataMap(map));
                    }

                    trigger = (OperableTrigger)tb.build();
                    trigger.setMisfireInstruction(misFireInstr);
                    trigger.setNextFireTime(nft);
                    trigger.setPreviousFireTime(pft);
                    this.setTriggerStateProperties(trigger, triggerProps);
                }
            }

            OperableTrigger var35 = trigger;
            return var35;
        } finally {
            closeResultSet(rs);
            closeStatement(ps);
        }
    }

    private boolean isTriggerStillPresent(PreparedStatement ps) throws SQLException {
        ResultSet rs = null;

        boolean var3;
        try {
            rs = ps.executeQuery();
            var3 = rs.next();
        } finally {
            closeResultSet(rs);
        }

        return var3;
    }

    private void setTriggerStateProperties(OperableTrigger trigger, TriggerPropertyBundle props) throws JobPersistenceException {
        if (props.getStatePropertyNames() != null) {
            Util.setBeanProps(trigger, props.getStatePropertyNames(), props.getStatePropertyValues());
        }
    }

    public JobDataMap selectTriggerJobDataMap(Connection conn, String triggerName, String groupName) throws SQLException, ClassNotFoundException, IOException {
        PreparedStatement ps = null;
        ResultSet rs = null;

        JobDataMap var7;
        try {
            ps = conn.prepareStatement(this.rtp("SELECT JOB_DATA FROM {0}TRIGGERS WHERE SCHED_NAME = {1} AND TRIGGER_NAME = ? AND TRIGGER_GROUP = ?"));
            ps.setString(1, triggerName);
            ps.setString(2, groupName);
            rs = ps.executeQuery();
            if (!rs.next()) {
                return new JobDataMap();
            }

            Map<?, ?> map = null;
            if (this.canUseProperties()) {
                map = this.getMapFromProperties(rs);
            } else {
                map = (Map)this.getObjectFromBlob(rs, "JOB_DATA");
            }

            rs.close();
            ps.close();
            if (null == map) {
                return new JobDataMap();
            }

            var7 = new JobDataMap(map);
        } finally {
            closeResultSet(rs);
            closeStatement(ps);
        }

        return var7;
    }

    public String selectTriggerState(Connection conn, TriggerKey triggerKey) throws SQLException {
        PreparedStatement ps = null;
        ResultSet rs = null;

        String var6;
        try {
            String state = null;
            ps = conn.prepareStatement(this.rtp("SELECT TRIGGER_STATE FROM {0}TRIGGERS WHERE SCHED_NAME = {1} AND TRIGGER_NAME = ? AND TRIGGER_GROUP = ?"));
            ps.setString(1, triggerKey.getName());
            ps.setString(2, triggerKey.getGroup());
            rs = ps.executeQuery();
            if (rs.next()) {
                state = rs.getString("TRIGGER_STATE");
            } else {
                state = "DELETED";
            }

            var6 = state.intern();
        } finally {
            closeResultSet(rs);
            closeStatement(ps);
        }

        return var6;
    }

    public TriggerStatus selectTriggerStatus(Connection conn, TriggerKey triggerKey) throws SQLException {
        PreparedStatement ps = null;
        ResultSet rs = null;

        TriggerStatus var15;
        try {
            TriggerStatus status = null;
            ps = conn.prepareStatement(this.rtp("SELECT TRIGGER_STATE, NEXT_FIRE_TIME, JOB_NAME, JOB_GROUP FROM {0}TRIGGERS WHERE SCHED_NAME = {1} AND TRIGGER_NAME = ? AND TRIGGER_GROUP = ?"));
            ps.setString(1, triggerKey.getName());
            ps.setString(2, triggerKey.getGroup());
            rs = ps.executeQuery();
            if (rs.next()) {
                String state = rs.getString("TRIGGER_STATE");
                long nextFireTime = rs.getLong("NEXT_FIRE_TIME");
                String jobName = rs.getString("JOB_NAME");
                String jobGroup = rs.getString("JOB_GROUP");
                Date nft = null;
                if (nextFireTime > 0L) {
                    nft = new Date(nextFireTime);
                }

                status = new TriggerStatus(state, nft);
                status.setKey(triggerKey);
                status.setJobKey(JobKey.jobKey(jobName, jobGroup));
            }

            var15 = status;
        } finally {
            closeResultSet(rs);
            closeStatement(ps);
        }

        return var15;
    }

    public int selectNumTriggers(Connection conn) throws SQLException {
        PreparedStatement ps = null;
        ResultSet rs = null;

        int var5;
        try {
            int count = 0;
            ps = conn.prepareStatement(this.rtp("SELECT COUNT(TRIGGER_NAME)  FROM {0}TRIGGERS WHERE SCHED_NAME = {1}"));
            rs = ps.executeQuery();
            if (rs.next()) {
                count = rs.getInt(1);
            }

            var5 = count;
        } finally {
            closeResultSet(rs);
            closeStatement(ps);
        }

        return var5;
    }

    public List<String> selectTriggerGroups(Connection conn) throws SQLException {
        PreparedStatement ps = null;
        ResultSet rs = null;

        try {
            ps = conn.prepareStatement(this.rtp("SELECT DISTINCT(TRIGGER_GROUP) FROM {0}TRIGGERS WHERE SCHED_NAME = {1}"));
            rs = ps.executeQuery();
            LinkedList list = new LinkedList();

            while(rs.next()) {
                list.add(rs.getString(1));
            }

            LinkedList var5 = list;
            return var5;
        } finally {
            closeResultSet(rs);
            closeStatement(ps);
        }
    }

    public List<String> selectTriggerGroups(Connection conn, GroupMatcher<TriggerKey> matcher) throws SQLException {
        PreparedStatement ps = null;
        ResultSet rs = null;

        try {
            ps = conn.prepareStatement(this.rtp("SELECT DISTINCT(TRIGGER_GROUP) FROM {0}TRIGGERS WHERE SCHED_NAME = {1} AND TRIGGER_GROUP LIKE ?"));
            ps.setString(1, this.toSqlLikeClause(matcher));
            rs = ps.executeQuery();
            LinkedList list = new LinkedList();

            while(rs.next()) {
                list.add(rs.getString(1));
            }

            LinkedList var6 = list;
            return var6;
        } finally {
            closeResultSet(rs);
            closeStatement(ps);
        }
    }

    public Set<TriggerKey> selectTriggersInGroup(Connection conn, GroupMatcher<TriggerKey> matcher) throws SQLException {
        PreparedStatement ps = null;
        ResultSet rs = null;

        try {
            if (this.isMatcherEquals(matcher)) {
                ps = conn.prepareStatement(this.rtp("SELECT TRIGGER_NAME, TRIGGER_GROUP FROM {0}TRIGGERS WHERE SCHED_NAME = {1} AND TRIGGER_GROUP = ?"));
                ps.setString(1, this.toSqlEqualsClause(matcher));
            } else {
                ps = conn.prepareStatement(this.rtp("SELECT TRIGGER_NAME, TRIGGER_GROUP FROM {0}TRIGGERS WHERE SCHED_NAME = {1} AND TRIGGER_GROUP LIKE ?"));
                ps.setString(1, this.toSqlLikeClause(matcher));
            }

            rs = ps.executeQuery();
            HashSet keys = new HashSet();

            while(rs.next()) {
                keys.add(TriggerKey.triggerKey(rs.getString(1), rs.getString(2)));
            }

            HashSet var6 = keys;
            return var6;
        } finally {
            closeResultSet(rs);
            closeStatement(ps);
        }
    }

    public int insertPausedTriggerGroup(Connection conn, String groupName) throws SQLException {
        PreparedStatement ps = null;

        int var5;
        try {
            ps = conn.prepareStatement(this.rtp("INSERT INTO {0}PAUSED_TRIGGER_GRPS (SCHED_NAME, TRIGGER_GROUP) VALUES({1}, ?)"));
            ps.setString(1, groupName);
            int rows = ps.executeUpdate();
            var5 = rows;
        } finally {
            closeStatement(ps);
        }

        return var5;
    }

    public int deletePausedTriggerGroup(Connection conn, String groupName) throws SQLException {
        PreparedStatement ps = null;

        int var5;
        try {
            ps = conn.prepareStatement(this.rtp("DELETE FROM {0}PAUSED_TRIGGER_GRPS WHERE SCHED_NAME = {1} AND TRIGGER_GROUP LIKE ?"));
            ps.setString(1, groupName);
            int rows = ps.executeUpdate();
            var5 = rows;
        } finally {
            closeStatement(ps);
        }

        return var5;
    }

    public int deletePausedTriggerGroup(Connection conn, GroupMatcher<TriggerKey> matcher) throws SQLException {
        PreparedStatement ps = null;

        int var5;
        try {
            ps = conn.prepareStatement(this.rtp("DELETE FROM {0}PAUSED_TRIGGER_GRPS WHERE SCHED_NAME = {1} AND TRIGGER_GROUP LIKE