DBGeneratorManager.java

Go to the documentation of this file.

package cedar.jetweb.db;

import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.HashSet;
import java.util.Set;

import java.sql.*;

import cedar.jetweb.*;
import cedar.jetweb.generator.*;
import cedar.jetweb.model.Model;
import cedar.jetweb.model.RunSeries;
import cedar.jetweb.model.ResultSearchPattern;

public abstract class DBGeneratorManager {

    public static void selectGeneratorParameters(RunSeries runseries)
    throws JetWebException {

    Generator gen = runseries.getGenerator();

    if(gen==null){
        try{
        gen = makeGen(runseries);
        }catch (JetWebDBException err){
        System.out.println(err.getMessage());
        }
    }
    String findAll = 
        "SELECT *  FROM generator_runseries WHERE runseries_id="+runseries.getId();
    try {
        selectParameters(gen,true,findAll);
    } catch (JetWebException e) {
        throw e;
    }
    }

    public static int getGeneratorId(String generatorName, String generatorVersion)
    throws JetWebException {

    String find = 
        "SELECT generator_id  FROM generators WHERE name='"+generatorName
        +"' AND version='"+generatorVersion+"'";

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

            if (rs.next()) {
            int id = rs.getInt("generator_id");
        rs.close();
        stmt.close();
        return id;
            } else {

        find = "SELECT MAX(generator_id) from generators";
        rs = stmt.executeQuery(find);

        if(rs.next()){
            Integer id = rs.getInt(1) + 1;
            rs.close();
            stmt.close();
            if(id==null) id = 1;
            return id;
        }
        }
    } catch (SQLException E){
        throw new JetWebDBException(E,find," Failed ");
    }
    return -1;
    }


    public static void selectGeneratorParameters(Model model)
    throws JetWebException {

    Generator gen = model.getGenerator();

    String findAll = 
        "SELECT *  FROM generator_model WHERE mdl_id="+model.getId();
    try {
        selectParameters(gen,true,findAll);
    } catch (JetWebException e) {
        throw e;
    }
    }


    public static void selectDefaultParameters(Generator gen, boolean hard) 
    throws JetWebException {

    String tableName = stripDots
        (gen.getName()+gen.getVersion()+"_defaults");
    String findAll = "SELECT *  FROM "+tableName;
    selectParameters(gen,hard,findAll);

    }
    
    private static synchronized void selectParameters(Generator gen, 
                              boolean hard,
                              String findAll)
    throws JetWebException {

    HashMap<String,HashMap<Integer,Integer>> intArrays = gen.getIntParameterArrays();
    HashMap<String,HashMap<Integer,Double>> realArrays = gen.getRealParameterArrays();
    HashMap<String,Integer> intParameters  = gen.getIntParameters();
    HashMap<String,Double>  realParameters = gen.getRealParameters();

    try {
            Statement stmt = DBConfig.getConnection().createStatement();
        ResultSet rs = stmt.executeQuery(findAll);
            
        while (rs.next()){
        boolean isArrayElement;
        boolean isInt;
            String name = rs.getString("name");         
            Integer index = rs.getInt("aindices");
        Integer iValue;
        Double rValue;
        if (rs.wasNull()){
            // This is a parameter.
            isArrayElement = false;
        } else {
            // This is an array element.
            isArrayElement = true;
        }
            iValue = rs.getInt("ivalue");
        if (rs.wasNull()){
            // This is a real value
            isInt = false;
            rValue = new Double(rs.getFloat("rvalue"));
        } else {
            // This is an integer value
            isInt = true;
            rValue = null;
        }

        if (isArrayElement) {

            if (isInt) {
            // Fill Integer arrays
            // If the array doesn't exists, create it.
            HashMap<Integer,Integer> map;
            if (!intArrays.containsKey(name)){
                map = new HashMap<Integer,Integer>();
                intArrays.put(name,map);
            }
            map = intArrays.get(name);
            
            if (map.containsKey(index)){
                if (hard) {
                map.remove(index);
                map.put(index,iValue);
                }
            } else {
                map.put(index,iValue);
            }

            } else {
            // Fill Real arrays
            // If the array doesn't exists, create it.
            HashMap<Integer,Double> map;
            if (!realArrays.containsKey(name)){
                map = new HashMap<Integer,Double>();
                realArrays.put(name,map);
            }
            map = realArrays.get(name);
            
            if (map.containsKey(index)){
                if (hard) {
                map.remove(index);
                map.put(index,rValue);
                }
            } else {
                map.put(index,rValue);
            }
            }

        } else {

            if (isInt) {
            // Fill Integer parameters
            if (intParameters.containsKey(name)){
                if (hard) {
                intParameters.remove(name);
                intParameters.put(name,iValue);
                }   
            } else {                    
                intParameters.put(name,iValue);
            }
            } else {
            // Fill Real parameters
            if (realParameters.containsKey(name)){
                if (hard) {
                realParameters.remove(name);
                realParameters.put(name,rValue);
                }
            } else {
                realParameters.put(name,rValue);
            }
            }
        }

        }
        rs.close();
        stmt.close();
    } catch (SQLException E){
        System.out.println("DBManager: Error reading parameters");
        System.out.println("SQLException: " + E.getMessage());
        System.out.println("SQLState:     " + E.getSQLState());
        System.out.println("VendorError:  " + E.getErrorCode());
        throw new JetWebDBException(E,findAll," Failed ");
    }
    
    }

    public static void addGeneratorParameters(String insert, Generator gen) 
    throws SQLException {
    
    Set<Map.Entry<String,Integer>> intParameters;
    Set<Map.Entry<String,Double>>  realParameters;
    Set<Map.Entry<String,HashMap<Integer,Integer>>> intArrays;
    Set<Map.Entry<String,HashMap<Integer,Double>>> realArrays;

    String values;

    Statement stmt = DBConfig.getConnection().createStatement();
    
    // First the Integer parameters
    intParameters  = gen.getIntParameters().entrySet(); 
    for (Map.Entry<String,Integer> entry : intParameters){
        if(gen.inModel(entry.getKey())){
        values = "'"+entry.getKey()+
            "',NULL,'"+entry.getValue()+"',NULL)";
        //System.out.println(insert+values);
        int rowsChanged = stmt.executeUpdate(insert+values);
        }
    }   
    // Now the real parameters
    realParameters = gen.getRealParameters().entrySet(); 
    for (Map.Entry<String,Double> entry : realParameters){
        if(gen.inModel(entry.getKey())){
        values = "'"+entry.getKey()+"',NULL,NULL,'" + 
            entry.getValue()+"')";      
        int rowsChanged = stmt.executeUpdate(insert+values);
        }       
    }   
    // Now the integer arrays.
    intArrays = gen.getIntParameterArrays().entrySet(); 
    for (Map.Entry<String,HashMap<Integer,Integer>> entry : intArrays){
        
        String arrayName = entry.getKey(); 
        if(gen.inModel(entry.getKey())){
        Set<Map.Entry<Integer,Integer>> array = 
            entry.getValue().entrySet();
        for (Map.Entry<Integer,Integer> arrayEntry : array){
            if(gen.inModel(entry.getKey(), arrayEntry.getKey())){
            Integer value = arrayEntry.getValue();
            Integer index = arrayEntry.getKey();            
            values = "'"+arrayName+"','"+
                index+"','"+value+"',NULL)";
            int rowsChanged = stmt.executeUpdate(insert+values);
            }
        }
        }
    }
    // Now the real arrays.
    realArrays = gen.getRealParameterArrays().entrySet(); 
    for (Map.Entry<String,HashMap<Integer,Double>> entry : realArrays){
        
        String arrayName = entry.getKey(); 
        if(gen.inModel(arrayName)){
        Set<Map.Entry<Integer,Double>> array = 
            entry.getValue().entrySet();
        for (Map.Entry<Integer,Double> arrayEntry : array){
            
            if(gen.inModel(arrayName, arrayEntry.getKey())){

            Double value = arrayEntry.getValue();
            Integer index = arrayEntry.getKey();            
            values = "'"+arrayName+"','"+index+
                "',NULL,'"+value+"')";
            int rowsChanged = stmt.executeUpdate(insert+values);
            }
        }
        }
    }
    stmt.close();
    }

    public static int getMaxIndex(String gname, String gversion, String pname) 
    throws JetWebException {

    String query=null;

    try {
        Statement stmt = DBConfig.getConnection().createStatement();
        String tableName = stripDots(gname+gversion+"_defaults");

            query = "SELECT MAX(aindices) max FROM "+tableName+" where name='"+pname+"'";
            ResultSet rs = stmt.executeQuery(query);

            if (rs.next()) {
        int max = rs.getInt("max");
        stmt.close();
        rs.close();
        return max;
            } else {
        rs.close();
        stmt.close();
        throw new JetWebException("Parameter "+pname+" in "+tableName,"Not found");
        }
    } catch (SQLException E){
        throw new JetWebDBException(E,query," Failed ");
    }
    }


    public static int getMinIndex(String gname, String gversion, String pname) 
    throws JetWebException {

    String query=null;

    try {
        Statement stmt = DBConfig.getConnection().createStatement();
        String tableName = stripDots(gname+gversion+"_defaults");

            query = "SELECT MIN(aindices) min FROM "+tableName+" where name='"+pname+"'";
            ResultSet rs = stmt.executeQuery(query);

            if (rs.next()) {
            int min = rs.getInt("min");
        rs.close();
        stmt.close();
        return min;
            } else {
        rs.close();
        stmt.close();
        throw new JetWebException("Parameter "+pname+" in "+tableName,"Not found");
        }
    } catch (SQLException E){
        throw new JetWebDBException(E,query," Failed ");
    }
    }

    public static Set<String> selectIntNames(String gname, String gversion) 
    throws JetWebException {

    String query=null;
    Set<String> names = new HashSet<String>();
    try {
        Statement stmt = DBConfig.getConnection().createStatement();
        String tableName = stripDots(gname+gversion+"_defaults");

            query = "SELECT name FROM "+tableName+" WHERE aindices IS NULL AND ivalue IS NOT NULL";
            ResultSet rs = stmt.executeQuery(query);

            while (rs.next()) {
        names.add(rs.getString("name"));
        }
        rs.close();
        stmt.close();

    } catch (SQLException E){
        throw new JetWebDBException(E,query," Failed ");
    }
    return names;   
    }
    public static Set<String> selectRealNames(String gname, String gversion) 
    throws JetWebException {

    String query=null;
    Set<String> names = new HashSet<String>();
    try {
        Statement stmt = DBConfig.getConnection().createStatement();
        String tableName = stripDots(gname+gversion+"_defaults");

            query = "SELECT name FROM "+tableName+" WHERE aindices IS NULL AND rvalue IS NOT NULL";
            ResultSet rs = stmt.executeQuery(query);

            while (rs.next()) {
        names.add(rs.getString("name"));
        }
        rs.close();
        stmt.close();

    } catch (SQLException E){
        throw new JetWebDBException(E,query," Failed ");
    }
    return names;   
    
    }
    public static Set<String> selectIntArrayNames(String gname, String gversion) 
    throws JetWebException {

    String query=null;
    Set<String> names = new HashSet<String>();
    try {
        Statement stmt = DBConfig.getConnection().createStatement();
        String tableName = stripDots(gname+gversion+"_defaults");

            query = "SELECT name FROM "+tableName+" WHERE aindices IS NOT NULL AND rvalue IS NULL";
            ResultSet rs = stmt.executeQuery(query);

            while (rs.next()) {
        names.add(rs.getString("name"));
        }
        rs.close();
        stmt.close();

    } catch (SQLException E){
        throw new JetWebDBException(E,query," Failed ");
    }
    return names;   
    
    }
    public static Set<String> selectRealArrayNames(String gname, String gversion) 
    throws JetWebException {

    String query=null;
    Set<String> names = new HashSet<String>();
    try {
        Statement stmt = DBConfig.getConnection().createStatement();
        String tableName = stripDots(gname+gversion+"_defaults");

            query = "SELECT name FROM "+tableName+" WHERE aindices IS NOT NULL AND rvalue IS NOT NULL";
            ResultSet rs = stmt.executeQuery(query);

            while (rs.next()) {
        names.add(rs.getString("name"));
        }
        rs.close();
        stmt.close();

    } catch (SQLException E){
        throw new JetWebDBException(E,query," Failed ");
    }
    return names;       
    }


    private static Generator makeGen(RunSeries runSeries)
    throws JetWebDBException{

    Generator gen=null;

    String query = 
        "select name, version from generators, runseries where runseries.generator_id=generators.generator_id and runseries_id="+
        runSeries.getId();

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

        while(rs.next()){
        String name = rs.getString("name");
        String ver = rs.getString("version");
        try{
            gen = Generator.Maker(name, ver);
        }catch(JetWebException err){
            System.out.println("unable to make generator");
            System.out.println(err.getMessage());
        }
        }
    }catch (SQLException E){
        throw new JetWebDBException(E,query," Failed ");
    }

    return gen;
    }

    public static String[] getNameAndVersion(int id) 
    throws JetWebException {

    String query=null;
    String[] nameAndVersion = new String[2];
    try {
        Statement stmt = DBConfig.getConnection().createStatement();
        String tableName = "generators";

            query = "SELECT name,version FROM "+tableName+" WHERE generator_id='"+id+"'";
            ResultSet rs = stmt.executeQuery(query);

            while (rs.next()) {
        nameAndVersion[0] = rs.getString("name");
        nameAndVersion[1] = rs.getString("version");
        }
        rs.close();
        stmt.close();

    } catch (SQLException E){
        throw new JetWebDBException(E,query," Failed ");
    }
    return nameAndVersion;  
    }


    public static Set<String> getVersions(String gname) 
    throws JetWebException {

    String query=null;
    Set<String> versions = new HashSet<String>();
    try {
        Statement stmt = DBConfig.getConnection().createStatement();
        String tableName = "generators";

            query = "SELECT version FROM "+tableName+" WHERE name='"+gname+"'";
            ResultSet rs = stmt.executeQuery(query);

            while (rs.next()) {
        versions.add(rs.getString("version"));
        }
        rs.close();
        stmt.close();

    } catch (SQLException E){
        throw new JetWebDBException(E,query," Failed ");
    }
    return versions;    
    }



    public static Set<String> allNames() 
    throws JetWebException {

    String query=null;
    Set<String> names = new HashSet<String>();
    try {
        Statement stmt = DBConfig.getConnection().createStatement();
        String tableName = "generators";

            query = "SELECT name FROM "+tableName;
            ResultSet rs = stmt.executeQuery(query);

            while (rs.next()) {
        String name = rs.getString("name");
        if (!names.contains(name)) {
            names.add(name);
        }
        }
        rs.close();
        stmt.close();

    } catch (SQLException E){
        throw new JetWebDBException(E,query," Failed ");
    }
    return names;   
    }

    public static String getDefaultVersion(String gname) 
    throws JetWebException {

    String query = null;
    String version = null;
    try {
        Statement stmt = DBConfig.getConnection().createStatement();
        String tableName = "generators";

            query = "SELECT version FROM "+tableName+" WHERE name='"
        +gname+"'"+" AND (is_default_version='1' OR is_default_version='2')";
            ResultSet rs = stmt.executeQuery(query);

            while (rs.next()) {
        version = rs.getString("version");
        }
        rs.close();
        stmt.close();

    } catch (SQLException E){
        throw new JetWebDBException(E,query," Failed ");
    }
    if (version==null) {
        throw new JetWebException("No default version found.",gname);
    }
    return version; 
    }

    public static void add(Generator gen) throws JetWebDBException {

    try {
        Statement stmt = DBConfig.getConnection().createStatement();
        String ins = "";
        try{
        ins = 
        "INSERT INTO generators (generator_id, name,version) VALUES('"
        + gen.getGeneratorId() + "', '" + 
        gen.getName()+"','"+gen.getVersion()+"')";
        }catch(Throwable err){
        System.out.println(err.getMessage());
        }
        int result = stmt.executeUpdate(ins);
        
        stmt.close();

    } catch (SQLException E){
        throw new JetWebDBException(E,gen.toString()," Failed ");       
    }
    }

    private static String stripDots(String word){
    int ii=word.indexOf(".");
    
    while(ii>-1){
        word = word.substring(0,ii)+word.substring(ii+1);
        ii=word.indexOf(".");
    }
    return word;
    }


    public static boolean checkProtonRelevance(Generator gen,
                           String name,Integer aindex) 
    throws JetWebException {

    return checkRelevance(gen,name,aindex,"rel_proton");

    }
    public static boolean checkPhotonRelevance(Generator gen,
                           String name,Integer aindex) 
    throws JetWebException {

    return checkRelevance(gen,name,aindex,"rel_photon");

    }


    private static boolean checkRelevance(Generator gen,String pName,
                    Integer aIndex, String columnName) 
    throws JetWebException {

    StringBuffer query=null;
    int rel=1;
    try {
        String tableName = gen.getName()+gen.getVersion()+"_defaults";
        DatabaseMetaData metaData = DBConfig.getConnection().getMetaData();
        ResultSet existingTables = metaData.getTables
        (DBConfig.getConnection().getCatalog(), null, "", null);
        
        boolean found=false;
        while(existingTables.next()&&!found){
        found = 
            (existingTables.getString("TABLE_NAME").
             equals(tableName))? true: false;
        }


        // if we can find no info in the DB about this parameter then
        // have to assume it is relevant
        if(!found)return true;

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

            query = new StringBuffer("SELECT "+columnName+" FROM "+tableName+" WHERE name='"+pName+"'");
        if (aIndex!=null){
        //query.append(" AND aindex='"+aIndex.toString()+"'");
        query.append(" AND aindices='"+aIndex.toString()+"'");
        }
            ResultSet rs = stmt.executeQuery(query.toString());

            while (rs.next()) {
        rel = rs.getInt(columnName);
        //System.out.println(query+ " : "+rel);
        }
        rs.close();
        stmt.close();

    } catch (SQLException E){
        throw new JetWebDBException(E,query.toString()," Failed ");
    }
    //System.out.println(rel==1);
    return (rel==1);

    }


}

Generated Wed Jan 17 09:14:27 GMT 2007