DBManager.java

Go to the documentation of this file.

package cedar.jetweb.db;

import cedar.jetweb.*;
import cedar.jetweb.generator.Generator;
import cedar.jetweb.model.*;
import cedar.jetweb.job.LogFile;
import cedar.jetweb.job.Cut;
import cedar.jetweb.job.CutCollection;

import java.io.File;

import java.sql.*;

import java.util.Enumeration;
import java.util.Vector;
import java.util.HashMap;


public abstract class DBManager {
    private static DBObjectManager objManager = new DBObjectManager();

    public static synchronized Integer getId(Model model)
    throws JetWebException{
    
    //if model already has valid id then just return that
    if(model.getId()>0){
     
        return model.getId();
    }

    //If matching model exists in database then return that id
    Vector<Model> matches = getConsistentModels(model);
    
    if(matches.size()==1){
        return matches.firstElement().getId();
    }else if(matches.size()>1){
        throw new JetWebException
        ("More than one model matches this Model!", 
         "Found Id"+matches.firstElement().getId());
    }

    //if we've got here then we need a new model id
    //use the next highest available id
    
    Integer mId;

    String query  = "SELECT MAX(mdl_id) from model";
    try{
        Statement stmt = DBConfig.getConnection().createStatement();
        ResultSet rs = stmt.executeQuery(query);
        if(rs.next()){
        mId = rs.getInt(1);

        if(mId==null){
            mId = 1;
        }else{
            ++mId;
        }
        rs.close();
        stmt.close();
        return mId;
        }
    }catch(Throwable err){
        System.out.println(err.getMessage());
        throw new JetWebException("Unable to query model table", 
                      "DBManager.getId(Model)");
    }
    return -1;
    }


    public static synchronized boolean addToDB(Model model)
        throws JetWebException {
        // Firstly, if this model has an ID already, see if it exists in the
        // DB. If it does, return false.

    if(exists("model", "mdl_id", model.getId()))return false;

        // Ok, this really is a new Model. Store it.

    // Now the model itself.
        String insertString = makeInsertModelString(model);
        int modelsFound = 0;

        try {
            Statement stmt = DBConfig.getConnection().createStatement();
            int result = stmt.executeUpdate(insertString);
        stmt.close();
            // Now store the generator parameters.
            addGeneratorParameters(model);

        } catch (SQLException E) {
            System.out.println("Error inserting model");
            System.out.println("SQLException: " + E.getMessage());
            System.out.println("SQLState:     " + E.getSQLState());
            System.out.println("VendorError:  " + E.getErrorCode());
            throw new JetWebDBException
        (E, insertString, "modelId:" + model.getId());
        }

        return (modelsFound > 0);
    }

    private static synchronized String makeInsertModelString(Model model)
        throws JetWebException {
        String ins1 = "INSERT INTO model" + 
        "(mdl_id, generator_id";
        String ins2 = ") VALUES('" + 
        model.getId() + "', '" +
        model.getGenerator().getGeneratorId()+ "'";
        ins1 = ins1 + ",photon_pdf";
        ins2 = ins2 + "," + model.getPhotonPDF(0);

        ins1 = ins1 + ",proton_pdf";
        ins2 = ins2 + "," + model.getProtonPDF(0);

        // Now add the RunSeriesCollectionId
        ins1 = ins1 + ",runseries_collection_id";
        ins2 = ins2 + ",'" + model.getRunSeriesCollection().getId()+ "'";

    ins1 = ins1 + ", description";
    ins2 = ins2 + ", '" + model.getDescription() + "' )";

        return ins1 + ins2;
    }

    public static synchronized void selectFromDB(Model model)
        throws JetWebException {
        String query = "SELECT * FROM model WHERE mdl_id=" + model.getId();

        try {
            Statement stmt = DBConfig.getConnection().createStatement();
            ResultSet rs = stmt.executeQuery(query);

            if (rs.next()) {
                fill(model, rs);
            } else {
        rs.close();
        stmt.close();
        throw new JetWebException("No such Model exists","ID="+model.getId());
        }

            rs.close();
            stmt.close();
        } catch (SQLException e) {
            System.out.println("Error reading model table " + e + "ModelId=" + model.getId());
            throw new JetWebDBException(e, query, "modelId:" + model.getId());
        }

        // Now fill the generator specific parameters.
        DBGeneratorManager.selectGeneratorParameters(model);
    }

    private static synchronized void fill(ResultSearchPattern pattern, ResultSet rs)
        throws JetWebException {
        fillCommon(pattern, rs);
    }

    // Fill variables which are common to all manifestations of the class.    
    // The generator is create but not filled.
    private static synchronized void fillCommon(ResultSearchPattern pattern, ResultSet rs)
        throws JetWebException {

        try {

        Object tmp = rs.getObject("photon_pdf");

            if (!rs.wasNull()&&tmp!=null) {
                pattern.getPhotonPDFList().clear();
                pattern.getPhotonPDFList().add
            (new PDF((Integer)tmp));
            }

            tmp = rs.getObject("proton_pdf");

            if (!rs.wasNull()&&tmp!=null) {
                pattern.getProtonPDFList().clear();
                pattern.getProtonPDFList().add
            (new PDF((Integer)tmp));
            }

        int generatorId    = rs.getInt("generator_id");
        Generator gen = Generator.Maker(generatorId);
            pattern.setGenerator(gen);
        } catch (SQLException E) {
            System.out.println("DBManager: error filling common variables");
            System.out.println("SQLException: " + E.getMessage());
            System.out.println("SQLState:     " + E.getSQLState());
            System.out.println("VendorError:  " + E.getErrorCode());
            throw new JetWebDBException(E, "", "Pattern:" + pattern.getParms());
        }
    }

    private static synchronized void fill(Model model, ResultSet rs)
        throws JetWebException {
        fillCommon(model, rs);
    //System.out.println(model.getGenerator());

        try {
            RunSeriesCollection rsc = 
        new RunSeriesCollection(rs.getInt("runseries_collection_id"));
        
            model.setRunSeriesCollection(rsc);
        model.setDescription(rs.getString("description"));
        
        } catch (SQLException e) {
            System.out.println("Error reading model table " + e);
            throw new JetWebDBException(e, "", "modelId:" + model.getId());
        }
    }

    public static synchronized Integer 
    getRunSeriesCollectionId(Vector<Integer> runseries)
    throws JetWebException{

        Vector<Integer> foundIds = new Vector<Integer>();

        try{
        PreparedStatement pstmt = 
        DBConfig.getConnection().prepareStatement("SELECT runseries_collection_id FROM runseries_collection WHERE runseries_id=?");

        boolean firstrow = true;

        for(Integer rs: runseries){
        pstmt.setInt(1, rs);
        ResultSet dbrs = pstmt.executeQuery();

        Vector<Integer> newIds = new Vector<Integer>();
        Vector<Integer> oldIds = new Vector<Integer>(foundIds);

        while(dbrs.next()){
            newIds.add(dbrs.getInt(1));
        }

        if(firstrow){
            foundIds = newIds;
            firstrow = false;
        }else{
            foundIds.clear();
            for(Integer id: newIds){
            if(oldIds.contains(id)){
                foundIds.add(id);
            }
            }
        }

        }

        
        }catch(SQLException err){
        throw new JetWebException(err);
        }

        if(foundIds.size()==1){
        return foundIds.get(0);
        }else if(foundIds.size()>1){
        Integer idRet = -1;
        Integer min = Integer.MAX_VALUE;
        try{
            PreparedStatement pstmt = 
            DBConfig.getConnection().prepareStatement
            ("SELECT COUNT(runseries_id) FROM " + 
             "runseries_collection WHERE " +
             "runseries_collection_id=?");

            for(Integer id: foundIds){
            pstmt.setInt(1, id);
            ResultSet dbrs = pstmt.executeQuery();
            if(dbrs.next()){
                Integer count = dbrs.getInt(1);
                if(count<min){
                min = count;
                idRet = id;
                }
            }
            }
                        
        }catch(SQLException err){
            throw new JetWebException(err);
        }
        return idRet;
        }
        
        return -1;
    }


    public static synchronized Vector<Model> getConsistentModels(RunSeries runseries)
        throws JetWebException {

        Vector<Model> models = new Vector<Model>();
    //System.out.print(runseries.getGenerator()+"  "+runseries.getGenerator(0));
        String query = makeModelQueryString(runseries,0);

        try {
            Statement stmt = DBConfig.getConnection().createStatement();
            ResultSet rs = stmt.executeQuery(query);

        System.out.println("Looking for models matching runseries");
        System.out.println(query);

            while (rs.next()) {
                int modelId = rs.getInt("mdl_id");
        System.out.println("trying model "+modelId);
                Model mdl = new Model(modelId);
        if(mdl.matches(runseries)){
            //if (mdl.getGenerator().isConsistentWith(runseries.getGenerator())){
            System.out.println("Adding model " + mdl.getId() +
                       " to list of consistent models");
            models.add(mdl);
        }
            }


            rs.close();
            stmt.close();
        } catch (SQLException E) {
            System.out.println("DBManager: error finding consistent models for runseries.");
            System.out.println("SQLException: " + E.getMessage());
            System.out.println("SQLState:     " + E.getSQLState());
            System.out.println("VendorError:  " + E.getErrorCode());
            throw new JetWebDBException(E, query, "RunseriesId:" + runseries.getId());
        }

        return models;
    }

    public static synchronized Vector<Model> getConsistentModels(ResultSearchPattern pattern)
        throws JetWebException {
        Vector<Model> models = new Vector<Model>();

    int genIndex=0;
    for (Generator gen : pattern.getGeneratorList()){

        String query = makeModelQueryString(pattern,genIndex);
        genIndex++;

        try {
        Statement stmt = DBConfig.getConnection().createStatement();
        ResultSet rs = stmt.executeQuery(query);
        
        while (rs.next()) {
            int modelId = rs.getInt("mdl_id");
            
            Model mdl = new Model(modelId);

            //if (mdl.getGenerator().isConsistentWith(gen)){
            if(pattern.matches(mdl)){
            models.add(mdl);
            }
        }

        rs.close();
        stmt.close();
        } catch (SQLException E) {
        System.out.println("DBManager: error finding consistent models for pattern.");
        System.out.println("SQLException: " + E.getMessage());
        System.out.println("SQLState:     " + E.getSQLState());
        System.out.println("VendorError:  " + E.getErrorCode());
        throw new JetWebDBException(E, query, pattern.getParms());
        }
    }

        return models;
    }

    // Make the query string using everything which is defined.
    // Looks at the genId-th generator in the list.
    private static String makeModelQueryString(ResultSearchPattern pattern, int genId)
        throws JetWebException {
        String query = "SELECT mdl_id FROM model ";
        StringBuffer q1 = new StringBuffer();
        boolean anything = false;

    Generator gen = pattern.getGenerator(genId);
    
    q1.append("(generator_id='" + gen.getGeneratorId() +"') AND ");

        if (pattern.getPhotonPDFList().size() == 1) {
        if(pattern.getPhotonPDF()!=null){
        q1.append("photon_pdf=" + pattern.getPhotonPDF() + " AND ");
        }
        }

        if (pattern.getPhotonPDFList().size() == 2) {
            q1.append
        ("(photon_pdf=" + 
         pattern.getPhotonPDF() + 
         " OR photon_pdf=" +
                pattern.getPhotonPDF(1) + ") AND ");
        }

        if (pattern.getProtonPDFList().size() == 1) {
        if(pattern.getProtonPDF()!=null){
        q1.append("proton_pdf=" + pattern.getProtonPDF() + " AND ");
        }
        }

        if (pattern.getProtonPDFList().size() == 2) {
            q1.append("(proton_pdf=" + pattern.getProtonPDF() + " OR proton_pdf=" +
                pattern.getProtonPDF(1) + ") AND ");
        }

    String query1 = q1.toString();
        if (query1.trim().length() != 0) {
            query1 = query1.substring(0, query1.lastIndexOf("AND"));
            query = query + " WHERE " + query1;
        }

        return query;
    }

    public static void selectFromDB(RunSeries runseries)
        throws JetWebException {
        String query = "SELECT * FROM runseries WHERE runseries_id=" + runseries.getId();

        try {
            Statement stmt = DBConfig.getConnection().createStatement();
            ResultSet rs = stmt.executeQuery(query);

            while (rs.next()) {
                fill(runseries, rs);        
            }

            rs.close();
            stmt.close();
        } catch (SQLException e) {
            System.out.println("Error reading runseries table " + e);
            throw new JetWebDBException(e, query, "runseriesId:" + runseries.getId());
        }

        // Now fill the generator specific parameters.
        try {
            DBGeneratorManager.selectGeneratorParameters(runseries);
        } catch (JetWebException jwe) {
            throw jwe;
        }
    }

    // Fill runseries specific variables.
    private static void fill(RunSeries runseries, ResultSet rs)
        throws JetWebException {
        fillCommon(runseries, rs);

        try {


            runseries.setMCProcessType(new MCProcessType(rs.getInt("process_id")));
            runseries.setDate(rs.getTimestamp("time"));
            runseries.setLumi(rs.getDouble("lumi"));
        runseries.setCrossSection(rs.getDouble("cross_section"));
        int cutCollectionId = rs.getInt("cut_collection_id");

        if(cutCollectionId!=0){

        runseries.getGenerator().setCutCollection
        (new CutCollection(cutCollectionId));
        }
        } catch (SQLException e) {
            System.out.println("Error reading runseries table " + e);
        }
    }

    private static void fill(Collision collision, ResultSet rs)
        throws JetWebException {
        try {
            Particle p1 = new Particle();
            p1.setName(rs.getString("particle1"));
            p1.setEnergy(rs.getFloat("energy1"));

            Particle p2 = new Particle();
            p2.setName(rs.getString("particle2"));
            p2.setEnergy(rs.getFloat("energy2"));

            collision.setId(rs.getInt("collision_id"));
            collision.addParticle(p1);
            collision.addParticle(p2);
        } catch (SQLException e) {
            System.out.println("Error reading collision table " + e);
        }
    }

    public static synchronized void resetLogTime(int runseriesId)
        throws JetWebException {
        String update = "UPDATE runseries SET time=NULL WHERE runseries_id=" + runseriesId;

        try {
            Statement stmt = DBConfig.getConnection().createStatement();
            stmt.executeUpdate(update);
        stmt.close();
        } catch (SQLException e) {
            System.out.println("DB access error in Logfile" + e);
            throw new JetWebDBException(e, update, "runseriesId:" + runseriesId);
        }
    }



    //public static synchronized void addLumi(double lumi, int runseriesId)
    public static synchronized void addLumi(LogFile log)
        throws JetWebException {
        String sqlString = "";

    String select = "";

    int logId = log.getId();

    if(logId>0){
        select = "SELECT lumi, log_id FROM logfile WHERE log_id="+logId;
    }else{
        log.getRunSeries().getCutCollection().store();
        select = "SELECT lumi, log_id FROM logfile WHERE runseries_id=" + 
        log.getRunSeries().getId() + 
        " AND cut_collection_id=" + 
        log.getRunSeries().getGenerator().getCutCollection().getId();
    }

        //String select = 
    //  "SELECT lumi FROM logfile WHERE runseries_id=" + runseriesId;

        try {
            Statement stmt = DBConfig.getConnection().createStatement();
            sqlString = select;

            ResultSet rs = stmt.executeQuery(sqlString);
            boolean hasWeighted = false;
            //double total = lumi;
        double total = log.getLumi();

            if (log.getLumi() < 0) {
                hasWeighted = true;
            }

        int id = -1;

            while (rs.next()) {
                double inc = rs.getDouble("lumi");
        id = rs.getInt("log_id");
                if (inc < 0.0) {
                    hasWeighted = true;
                } else {
                    total = total + inc;
                }

            }

            // Negative lumi means there are weighted events.
            if (hasWeighted) {
        System.out.println
            ("DBManager: Found weighted events");
                total = -1.0 * total;
            }

        // Need to get the exis


            sqlString = "UPDATE runseries SET lumi=" + total + 
        " WHERE runseries_id=" + log.getRunSeries().getId();
                //runseriesId;

            stmt.executeUpdate(sqlString);
        rs.close();
        stmt.close();
        } catch (SQLException e) {
            System.out.println("DB access error in Logfile" + e);
            //throw new JetWebDBException(e, sqlString, "runseriesId:" + runseriesId);
        throw new JetWebDBException(e, sqlString, "runseriesId:" + 
                    log.getRunSeries().getId());
        }
    }

    public static Enumeration<Integer> getAllRunSeriesIds() throws JetWebDBException {
        Vector<Integer> ids = new Vector<Integer>();
        String sqlString = "";
        String select = "SELECT runseries_id FROM runseries";

        try {
            Statement stmt = DBConfig.getConnection().createStatement();
            sqlString = select;

            ResultSet rs = stmt.executeQuery(sqlString);

            while (rs.next()) {
                Integer id = new Integer(rs.getInt("runseries_id"));
                ids.add(id);
            }
        rs.close();
        stmt.close();
        } catch (SQLException e) {
            System.out.println("DB access error in RunSeries" + e);
            throw new JetWebDBException(e, sqlString, "getAllRunSeriesIds");
        }

        return ids.elements();
    }

    //Don't think we actually use this

    /*
    public static void updateLumi(RunSeries runseries, double newLumi)
        throws JetWebDBException {
        if (runseries.getLumi() != newLumi) {
            runseries.setLumi(newLumi);

            String update = "UPDATE runseries SET lumi=" + newLumi + " WHERE runseries_id=" +
                runseries.getId();

            try {
                Statement stmt = DBConfig.getConnection().createStatement();
                int i = stmt.executeUpdate(update);
        stmt.close();
            } catch (SQLException e) {
                throw new JetWebDBException(e, update, "runseriesId:" + runseries.getId());
            }
        }
    }
    */


    public static void zero(RunSeries lp) {
        if (lp != null) {
            String zeroIt =
                "update predicted_point set y=0.0,dy_up=0.0,dy_down=0.0 where runseries_id=" +
                lp.getId();

            try {
                Statement stmt = DBConfig.getConnection().createStatement();
                stmt.executeUpdate(zeroIt);
        stmt.close();
        } catch (SQLException e) {
        System.out.println("DBManager: Error executing " + zeroIt);
            }

            zeroIt = "update runseries set lumi=0.0 where runseries_id=" + lp.getId();

            try {
                Statement stmt = DBConfig.getConnection().createStatement();
                stmt.executeUpdate(zeroIt);
        stmt.close();
            } catch (SQLException e) {
                System.out.println("DBManager: Error executing " + zeroIt);
            }
        } else {
            System.out.println("DBManager: trapped attempt to zero a null runseries");
        }
    }

    public static void selectFromDB(MCProcessType proc)
        throws JetWebException {
        String query = 
        "SELECT * FROM process_type WHERE process_id=" + proc.getId();

        try {
            Statement stmt = DBConfig.getConnection().createStatement();
            ResultSet rs = stmt.executeQuery(query);

        if(objManager.getDBConnection()==null){
        objManager.passDBConnection
            (DBConfig.getDBConnectionManager());
        }

            while (rs.next()) {
        objManager.fillObject(proc, rs);
            }

            rs.close();
            stmt.close();
        } catch (SQLException e) {
            System.out.println("Error reading process_type table " + e);
            throw new JetWebDBException(e, query, "processId:" + proc.getId());
        }
    }

    public static boolean addToDB(MCProcessType proc)
        throws JetWebException {

    boolean newRow = false; 
        if (proc.getId() > 0) {
            if (exists("process_type", "process_id", proc.getId())) {
        deleteFromDB("process_type","process_id",proc.getId());
        newRow = true;
            }
        }
    if(objManager.getDBConnection()==null){
        objManager.passDBConnection
        (DBConfig.getDBConnectionManager());
    }   
    objManager.writeObject(proc,"process_type",DBConfig.JETWEB);

        return newRow;
    }
    public static boolean deleteFromDB(MCProcessType proc)
        throws JetWebException {

    boolean success = false;
        if (proc.getId() > 0) {
            if (exists("process_type", "process_id", proc.getId())) {
        deleteFromDB("process_type","process_id",proc.getId());
        success = true;
            }
        }
        return success;
    }

    public static void selectFromDB(RunSeriesCollection rsc)
        throws JetWebException {
        String query = "SELECT * FROM runseries_collection WHERE runseries_collection_id=" +
            rsc.getId();

        try {
            Statement stmt = DBConfig.getConnection().createStatement();
            ResultSet rs = stmt.executeQuery(query);

            while (rs.next()) {
                int rsId = rs.getInt("runseries_id");
                //RunSeries runSeries = new RunSeries(rsId);
        RunSeries runSeries  = RunSeries.Maker(rsId);
                //rsc.getRunSeriesList().add(runSeries);
        rsc.add(runSeries);
            }

            rs.close();
            stmt.close();
        } catch (SQLException e) {
            System.out.println("Error reading runseries_collection table " + e);
            throw new JetWebDBException(e, query, "runseries_collection_id:" + rsc.getId());
        }
    }

    public static Vector<MCProcessType> getAllMCProcessTypes(boolean selectable) 
    throws JetWebException {

    return getAllMCProcessTypes(null,selectable);
    }

    public static Vector<MCProcessType> getAllMCProcessTypes(Collision collision,boolean selectable)
        throws JetWebException {

        Vector<MCProcessType> procList = new Vector<MCProcessType>();

    StringBuffer query = new StringBuffer("SELECT * FROM process_type ");
    if ((collision!=null)|| selectable) {query.append(" WHERE ");}
    if (collision!=null) {
        query.append("collision_id='" + collision.getId()+"'");
        if (selectable) {query.append(" AND ");}
    }
    if (selectable) query.append(" is_valid='1'");

        try {
            Statement stmt = DBConfig.getConnection().createStatement();
            ResultSet rs = stmt.executeQuery(query.toString());

            while (rs.next()) {
                MCProcessType proc = new MCProcessType();
        objManager.fillObject(proc, rs);
                procList.add(proc);
            }

            rs.close();
            stmt.close();
        } catch (SQLException e) {
            System.out.println("Error reading process_type table " + e);
            throw new JetWebDBException(e, query.toString(), "?");
        }

        return procList;
    }

    public static boolean exists(String tableName, String fieldName, int id)
        throws JetWebException {
        boolean exists = false;
        String query = " ";

        try {
            Statement stmt = DBConfig.getConnection().createStatement();
            query = "SELECT * FROM " + tableName + " where " + fieldName + "=" + id;

            ResultSet rs = stmt.executeQuery(query);

            if (rs.next()) {
                exists = true;
            }

            rs.close();
            stmt.close();

            return exists;
        } catch (SQLException E) {
            throw new JetWebDBException(E, query, "modelId:" + id);
        }
    }


    public static void deleteFromDB(String tableName, String fieldName, int id)
        throws JetWebException {

        String query = " ";

        try {
            Statement stmt = DBConfig.getConnection().createStatement();
            query = "DELETE FROM " + tableName + " where " + fieldName + "=" + id;

            int res = stmt.executeUpdate(query);

            stmt.close();

        } catch (SQLException E) {
            throw new JetWebDBException(E, query, "dbmanager");
        }
    }


    public static boolean addToDB(Collision collision)
        throws JetWebException {
        if (collision.getId() > 0) {
            if (exists("collision", "collision_id", collision.getId())) {
                throw new JetWebException("Attempt to re-store an existing collision.",
                    "id = " + collision.getId());
            }
        }

        String ins = "INSERT INTO collision" + "(particle1,particle2,energy1,energy2) VALUES('" +
            collision.getParticle1().getName() + "','" +
            collision.getParticle2().getName() + "','" +
            collision.getParticle1().getEnergy() + "','" + collision.getParticle2().getEnergy() +
            "')";

        try {
            Statement stmt = DBConfig.getConnection().createStatement();
            int result = stmt.executeUpdate(ins);
            stmt.close();
        } catch (SQLException E) {
            throw new JetWebDBException(E, ins, "Id:" + collision.getId());
        }

        return true;
    }

    public static boolean selectFromDB(Collision collision)
        throws JetWebException {
        if (collision.getId() <= 0) {
            throw new JetWebException("Attempt to select collision with id not defined",
                "id was " + collision.getId());
        }

        String query = "SELECT * FROM collision WHERE collision_id=" + collision.getId();

        try {
            Statement stmt = DBConfig.getConnection().createStatement();
            ResultSet rs = stmt.executeQuery(query);

            while (rs.next()) {
                fill(collision, rs);
            }

            rs.close();
            stmt.close();
        } catch (SQLException e) {
            throw new JetWebDBException(e, query, "collision_id:" + collision.getId());
        }

        return true;
    }

    public static Vector<Collision> getAllCollisions() throws JetWebException {
        Vector<Collision> list = new Vector<Collision>();
        String query = "SELECT * FROM collision";

        try {
            Statement stmt = DBConfig.getConnection().createStatement();
            ResultSet rs = stmt.executeQuery(query);

            while (rs.next()) {
                Collision collision = new Collision();
                fill(collision, rs);
                list.add(collision);
            }

            rs.close();
            stmt.close();
        } catch (SQLException e) {
            System.out.println("Error reading process_type table " + e);
            throw new JetWebDBException(e, query, "?");
        }

        return list;
    }

    public static boolean checkCollision(int collId, int procId)
        throws JetWebException {
        String query = "SELECT * FROM process_type WHERE process_id='" + procId +
            "' AND collision_id='" + collId + "'";

        try {
            Statement stmt = DBConfig.getConnection().createStatement();
            ResultSet rs = stmt.executeQuery(query);

            if (rs.next()) {
                rs.close();
                stmt.close();

                return true;
            }

            rs.close();
            stmt.close();

            return false;
        } catch (SQLException e) {
            System.out.println("Error reading process_type table " + e);
            throw new JetWebDBException(e, query, "?");
        }
    }

    public static synchronized void deleteParms(int runseriesId)
        throws JetWebException {
        System.out.println("DBManager: Deleting runseries ID=" + runseriesId);

        String deleteString = "";
        String deleteString1 = "DELETE FROM runseries WHERE runseries_id=" + runseriesId;
        String deleteString2 = "DELETE FROM generator_runseries WHERE runseries_id=" + runseriesId;

        try {
            Statement stmt = DBConfig.getConnection().createStatement();
            deleteString = deleteString1;
            stmt.executeUpdate(deleteString);
            deleteString = deleteString2;
            stmt.executeUpdate(deleteString);
            stmt.close();
        } catch (SQLException e) {
            System.out.println("Error deleting incorrect runseries " + e + "RunSeriesId=" +
                runseriesId);
            throw new JetWebDBException(e, deleteString, "id=" + runseriesId);
        }
    }

    public static synchronized void addRunSeries(RunSeries runSeries)
        throws JetWebException {

    //get a new id for the runseries:

    String selectMax = "SELECT MAX(runseries_id) FROM runseries";

    Integer newId=1;

    try{
        Statement stmt = DBConfig.getConnection().createStatement();
        ResultSet rs = stmt.executeQuery(selectMax);

        while(rs.next()){
        Integer tmpId = rs.getInt(1);
        if(tmpId!=null && tmpId>=newId) newId=tmpId+1;
        }
        
    }catch(SQLException err){
        throw new JetWebException(err);
    }


        MCProcessType proc = runSeries.getMCProcessType();
    
    CutCollection cuts = runSeries.getCutCollection();
    if(cuts!=null) cuts.store();

        // First add those things which are always defined.
        String ins1 = "INSERT INTO runseries " + 
        "(runseries_id, " + 
        "lumi, " + 
        "cross_section, " + 
        "generator_id, " + 
        "process_id, " + 
        "cut_collection_id";

        String ins2 = "values(" + newId + "," + 
        runSeries.getLumi() + "," 
        + runSeries.getCrossSection() + ",'"
        + runSeries.getGenerator().getGeneratorId()+ "','" 
            + proc.getId()+ "','" +
        runSeries.getCutCollection().getId() + 
        "'";

        // Now those rows which may or may not be filled.
        // General Photon things.
        if (proc.hasPhoton()) {
            ins1 = ins1 + ", photon_pdf";
            ins2 = ins2 + "," + runSeries.getPhotonPDF();
        }

        // General Proton things.
        if (proc.hasProton()) {
            ins1 = ins1 + ", proton_pdf";
            ins2 = ins2 + "," + runSeries.getProtonPDF() + "";
        }

        String ins = ins1 + ")" + ins2 + ")";

        try {
            Statement stmt = DBConfig.getConnection().createStatement();
            int rowsChanged = stmt.executeUpdate(ins);
            stmt.close();
        } catch (SQLException e) {
            throw new JetWebDBException(e, ins, "runSeriesId:" + runSeries.getId());
        }

        String query = "SELECT MAX(runseries_id) FROM runseries";

        try {
            Statement stmt = DBConfig.getConnection().createStatement();
            ResultSet rs = stmt.executeQuery(query);
            rs.next();

            int id = rs.getInt(1);

            runSeries.setId(id);

            addGeneratorParameters(runSeries);

            // Check there were no errors. Could get errors if we allow asynchronous
            // multithreaded DB access?
            //log.setRunSeriesId(matchRunSeriesId(log));
            if ((runSeries == null) || (runSeries.getId() <= 0)) {
                // Something went wrong. The data added to the DB did not match the
                // runseries it was supposed to come from.
                // Delete the RunSeries we added, and throw an exception.
        rs.close();
        stmt.close();
                deleteParms(id);
                throw new JetWebDBException("Failed to add runseries", "deleted");
            }

            rs.close();
            stmt.close();
        } catch (SQLException E) {
            System.out.println("SQLException: " + E.getMessage());
            System.out.println("SQLState:     " + E.getSQLState());
            System.out.println("VendorError:  " + E.getErrorCode());
            throw new JetWebDBException(E, query, "");
        }
    }


    // Add the generator tables to the db for a runSeries.
    private static void addGeneratorParameters(RunSeries runSeries)
        throws JetWebException {
        Generator gen = runSeries.getGenerator();
        String insert =
            "INSERT INTO generator_runseries (runseries_id,name,aindices,ivalue,rvalue) values ('" +
            runSeries.getId() + "',";

        try {
            DBGeneratorManager.addGeneratorParameters(insert, gen);
        } catch (SQLException E) {
            System.out.println("DBManager: error adding generator parameters: " + insert);
            System.out.println("SQLException: " + E.getMessage());
            System.out.println("SQLState:     " + E.getSQLState());
            System.out.println("VendorError:  " + E.getErrorCode());
            throw new JetWebDBException(E, insert, "runSeriesId:" + runSeries.getId());
        }
    }

    // Add the generator tables to the db for a runSeries.
    private static void addGeneratorParameters(Model model)
        throws JetWebException {
        Generator gen = model.getGenerator();
        String insert = "INSERT INTO generator_model (mdl_id,name,aindices,ivalue,rvalue) values ('" +
            model.getId() + "',";

        try {
            DBGeneratorManager.addGeneratorParameters(insert, gen);
        } catch (SQLException E) {
            System.out.println("DBManager: error adding generator model: " + insert);
            System.out.println("SQLException: " + E.getMessage());
            System.out.println("SQLState:     " + E.getSQLState());
            System.out.println("VendorError:  " + E.getErrorCode());
            throw new JetWebDBException(E, insert, "ModelId:" + model.getId());
        }
    }

    public static synchronized Vector<RunSeries> getConsistentRunSeries(MCProcessType proc, Model model)
        throws JetWebException {
    HashMap<Integer, RunSeries> foundRunSeries = 
        new HashMap<Integer, RunSeries>();
        //Vector<RunSeries> matchedList = new Vector<RunSeries>();

        String query = makeRunSeriesQueryString(model, proc);

        try {
            Statement stmt = DBConfig.getConnection().createStatement();
            ResultSet rs = stmt.executeQuery(query);
        
            while (rs.next()) {
                // We have a matching row. Get the id.
                int rsid = rs.getInt("runseries_id");
        boolean procMatch = true;

        if (rsid>=0 && !foundRunSeries.containsKey(rsid)) {
            // Check the processtype, in case the process_id 
            // was not already specified.
            if (rsid >= 0 && proc !=null && proc.getId()<0) {
            // Check the MCProcessType. If the
            // MCProcessType has a valid Id, then the check
            // was done in the original query. If not, then
            // the MCProcessType must have been only partially
            // specified, so lets see if the MCProcessType
            // belonging to this RunSeries matches it.
            int procId = rs.getInt("process_id");
            MCProcessType thisProc = new MCProcessType(procId);
            if (thisProc.matches(proc)) {
                procMatch = false;
            }
            }

            if (procMatch) {
            // Now build the runSeries.
            //RunSeries runSeries = new RunSeries(rsid);
            RunSeries runSeries = RunSeries.Maker(rsid);

            //if (runSeries.getGenerator().isConsistentWith(model.getGenerator())){
            if(runSeries.matches(model)){
                //matchedList.add(new RunSeries(rsid));
                //matchedList.add(runSeries);
                foundRunSeries.put(rsid, runSeries);
            }else{
                System.out.println
                ("Runseries is not consistent with model");
            }
            }
                }
            }
        rs.close();
            stmt.close();
        } catch (SQLException E) {
            System.out.println("SQLException: " + E.getMessage());
            System.out.println("SQLState:     " + E.getSQLState());
            System.out.println("VendorError:  " + E.getErrorCode());
            throw new JetWebDBException(E, query, "ModelId:" + model.getId());
        }

        return new Vector<RunSeries>(foundRunSeries.values());
    }

    public static synchronized int matchRunSeriesId(RunSeries runSeries)
        throws JetWebException {

        int rtn = -1;
        String query = makeRunSeriesQueryString
        (runSeries, runSeries.getMCProcessType());


        try {
            Statement stmt = DBConfig.getConnection().createStatement();

            // query the runseries table for rows matching the parameters of 
            // the input runseries.
            ResultSet rs = stmt.executeQuery(query);

            while (rs.next() && (rtn <= 0)) {
                // We have a matching row. Get the id.
                rtn = rs.getInt("runseries_id");

                if (rtn >= 0) {
                    // Now check generator specific auxilliary tables.
                                
            //RunSeries matchRunSeries = new RunSeries(rtn);
            RunSeries matchRunSeries = RunSeries.Maker(rtn);
            if (!(matchRunSeries.getGenerator().isConsistentWith(runSeries.getGenerator()))){
            rtn = -1;
            }
                }
            }
        rs.close();
            stmt.close();
        } catch (SQLException E) {
            System.out.println("DBManager.matchRunSeriesId ");
            System.out.println(query);
            System.out.println("SQLException: " + E.getMessage());
            System.out.println("SQLState:     " + E.getSQLState());
            System.out.println("VendorError:  " + E.getErrorCode());
            throw new JetWebDBException(E, query, "runseries Id:" + runSeries.getId());
        }

        return rtn;
    }

    private static String makeRunSeriesQueryString(ResultSearchPattern pattern, MCProcessType proc)
        throws JetWebException {
        StringBuffer query = new StringBuffer
        ("SELECT * FROM runseries WHERE generator_id='" +
            pattern.getGenerator().getGeneratorId() + 
         "'");

        if (proc.getId() > 0) {
            query.append(" AND process_id='" + proc.getId() + "'");
        }

        if (proc.hasPhoton()) {
            // add test on photon variables
            query.append(" AND photon_pdf=" + pattern.getPhotonPDF());
        }

        if (proc.hasProton()) {
            // add test on proton variables
            query.append(" AND proton_pdf=" + pattern.getProtonPDF());
        }

    //  query.append("'");

        return query.toString();
    }

    public static void selectId(Collision collision) throws JetWebException {

        String checkquery = "SELECT * FROM collision WHERE particle1='" +
            collision.getParticle1().getName() + "' AND particle2='" +
            collision.getParticle2().getName() + "' AND energy1='" +
            collision.getParticle1().getEnergy() + "' AND energy2='" +
            collision.getParticle2().getEnergy() + "'";

        try {
            Statement stmt = DBConfig.getConnection().createStatement();
            ResultSet rs = stmt.executeQuery(checkquery);

            if (rs.next()) {
                collision.setId(rs.getInt("collision_id"));
                rs.close();
                stmt.close();
            }

            rs.close();
            stmt.close();
        } catch (SQLException E) {
            throw new JetWebDBException(E, "failed to select ID", checkquery);
        }
    }

    public static void selectId(MCProcessType proc) throws JetWebException {
        String checkquery = "SELECT * FROM process_type WHERE collision_id='" +
            proc.getCollision().getId() + "' AND process_name='" + proc.getMCProcessName() + "'";

        try {
            Statement stmt = DBConfig.getConnection().createStatement();
            ResultSet rs = stmt.executeQuery(checkquery);

        /*
            if (rs.next()) {
                proc.setId(rs.getInt("process_id"));
                rs.close();
                stmt.close();
            }
        */

        if(objManager.getDBConnection()==null){
        objManager.passDBConnection
            (DBConfig.getDBConnectionManager());
        }

        if(rs.next()){
        objManager.fillObject(proc, rs);
        rs.close();
        stmt.close();
        }

            rs.close();
            stmt.close();
        } catch (SQLException E) {
            throw new JetWebDBException(E, "failed to select ID", checkquery);
        }
    }


    public static boolean selectId(RunSeriesCollection rsc)
    throws JetWebException{
    
    if(rsc.getId() >=0) return true;

    Statement stmt;
    ResultSet rs;
    String query = 
        "SELECT MAX(runseries_collection_id) FROM runseries_collection";

    try {
        stmt = DBConfig.getConnection().createStatement();
        rs = stmt.executeQuery(query);
        if (rs.next()){
        rsc.setId(rs.getInt(1)+1);
        } else {
        rsc.setId(1);
        }
    } catch (SQLException E) {
        throw new JetWebDBException(E, query, "Id:" + rsc.getId());
    }

    return false;
    }

    public static synchronized boolean addToDB(RunSeriesCollection rsc)
        throws JetWebException {

        if (selectId(rsc)) {
            if (exists
        ("runseries_collection", "runseries_collection_id", 
         rsc.getId())) {
                throw new JetWebException
            ("Attempt to re-store an existing run series collection.",
                    "id = " + rsc.getId());
            }
        }

    Statement stmt;
    //ResultSet rs;
    
    //make sure we don't store the same runseries in the collection twice
    Vector<Integer> storedRunSeries = new Vector<Integer>();

    for (RunSeries runSeries : rsc.getRunSeriesList()){
        if(!storedRunSeries.contains(runSeries.getId())){
        String ins = 
            "INSERT INTO runseries_collection (runseries_collection_id,runseries_id) VALUES('" 
            + rsc.getId() + "','" 
            + runSeries.getId() + "')";
        
        try {
            stmt = DBConfig.getConnection().createStatement();
            int result = stmt.executeUpdate(ins);
            storedRunSeries.add(runSeries.getId());
            //rs.close();
            stmt.close();
        } catch (SQLException E) {
            throw new JetWebDBException(E, ins, "Id:" + rsc.getId());
        }
        }
    }

        return true;
    }

    public static synchronized boolean updateDB
    (RunSeriesCollection rsc, RunSeries runseries)
    throws JetWebException{
    

    try{

        String sql = "SELECT * FROM runseries_collection WHERE " +
        "runseries_collection_id = " + rsc.getId() + 
        " AND runseries_id="+runseries.getId();

        Statement stmt = DBConfig.getConnection().createStatement();
        ResultSet rs = stmt.executeQuery(sql);
        if(rs.next()){
        rs.close();
        stmt.close();
        return false;
        }
        rs.close();
        sql= "INSERT INTO runseries_collection(" + 
        "runseries_collection_id, runseries_id) VALUES ("+
        rsc.getId()+"," + runseries.getId() +")";

        stmt.executeUpdate(sql);
        stmt.close();
    }catch(SQLException err){
        throw new JetWebException(err);
    }

    return true;
    }


    public static synchronized boolean updateDB(RunSeriesCollection rsc)
        throws JetWebException {

        if (rsc.getId() < 0 || 
        !exists("runseries_collection", "runseries_collection_id", 
            rsc.getId())) {
        addToDB(rsc);
        //throw new JetWebException("Attempt to update a non-existant run series collection.",
        //            "id = " + rsc.getId());
    }

    String sql = "";

    try {
        
        Statement stmt = DBConfig.getConnection().createStatement();
        ResultSet rs;
        
        for (RunSeries runSeries : rsc.getRunSeriesList()){
        
        sql = "SELECT * FROM runseries_collection WHERE runseries_collection_id="
            +rsc.getId()+" AND runseries_id="+runSeries.getId();

        rs = stmt.executeQuery(sql);
        if (!rs.next()) {
            
            sql = 
            "INSERT INTO runseries_collection (runseries_collection_id,runseries_id) VALUES('" 
            + rsc.getId() + "','" 
            + runSeries.getId() + "')";
            int result = stmt.executeUpdate(sql);
        }
        rs.close();
        }

        stmt.close();
    } catch (SQLException E) {
        throw new JetWebDBException(E, sql, "Id:" + rsc.getId());
    }

        return true;
    }

}

Generated Wed Jan 17 09:14:27 GMT 2007