geodatabaseojb.java

来自「用于GIS(全球地理系统)的分析和处理的代码。」· Java 代码 · 共 492 行 · 第 1/2 页

    /////////////////////////////////////////////////////////////////////////////////////////
    ///// gestion de la persistance /////////////////////////////////////////////////////////
    /////////////////////////////////////////////////////////////////////////////////////////        
    /** Rend persistant un objet. 
        A appeler a l'interieur d'une transaction ouverte.*/
    public void makePersistent(Object obj) {
        try {
            _db.makePersistent(obj);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
       
    /** Detruit un objet persistant. 
        A appeler a l'interieur d'une transaction ouverte. */
    public void deletePersistent(Object obj) {
        try {
            _db.deletePersistent(obj);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }        
                
    
    
    /////////////////////////////////////////////////////////////////////////////////////////
    ///// chargement d'objets ///////////////////////////////////////////////////////////////
    /////////////////////////////////////////////////////////////////////////////////////////
    /** Charge l'objet d'identifiant id. 
        Passer un Integer pour id, si l'identifiant est un int.
        Renvoie null si l'objet d'identifiant id n'existe pas.*
        A appeler a l'interieur d'une transaction ouverte. */
    public java.lang.Object load(Class clazz, Object id) {
        try {                
            OQLQuery query = _odmg.newOQLQuery();
            query.create("select x from "+clazz.getName()+" where id = $0");
            query.bind( id );
            DList result = (DList) query.execute();
            if (result.size() > 0) return result.get(0);
            else {                  
                System.out.println("objet non trouve - id = "+id); 
                return null;
            }
        } catch (Exception ee) {
            ee.printStackTrace();
            return null;
        }
    }            
    
    /** Charge tous les objets persistants de la classe theClass et les met dans une liste.
        A appeler a l'interieur d'une transaction ouverte. */    
    public List loadAll(Class theClass) {
        try {
            OQLQuery query = _odmg.newOQLQuery();
            query.create("select x from "+theClass.getName());
            DList result = (DList) query.execute();
            return result;
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }        
    
	/** Charge tous les FT_Feature de la classe theClass dans la classe FT_FeatureCollection.
		A appeler a l'interieur d'une transaction ouverte. 
		La classe theClass doit etre une sous-classe de FT_Feature, sinon renvoie une liste vide. */
	public FT_FeatureCollection loadAllFeatures(Class featureClass) {
	  FT_FeatureCollection result = new FT_FeatureCollection();
	  if ((FT_Feature.class).isAssignableFrom(featureClass)) {
		try {
			OQLQuery query = _odmg.newOQLQuery();
			query.create("select x from "+featureClass.getName());
			DList list = (DList) query.execute();
			Iterator iter = list.iterator();
			while (iter.hasNext()) {
				FT_Feature feature = (FT_Feature) iter.next();
				result.add(feature);
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	  } else {
		System.out.println("loadAllFeatures() : La classe passee en parametre n'est pas une sous-classe de FT_Feature");
	  }
	  return result;
	}
    
	/** Charge tous les FT_Feature de la classe theClass dans la classe featureListClass.
		A appeler a l'interieur d'une transaction ouverte. 
		La classe theClass doit etre une sous-classe de FT_Feature, sinon renvoie une liste vide.
		La classe featureListClass doit etre un sous classe de FT_FeatureCollection.*/
	public Object loadAllFeatures(Class featureClass, Class featureListClass) {
	  Object result = null;
	  try {
		  result = featureListClass.newInstance();
	  } catch (Exception e)  {
		  e.printStackTrace();
	  }
	  if ((FT_Feature.class).isAssignableFrom(featureClass)) {
	  	try {
            OQLQuery query = _odmg.newOQLQuery();
            query.create("select x from "+featureClass.getName());
            DList list = (DList) query.execute();
            Iterator iter = list.iterator();
            while (iter.hasNext()) {
                FT_Feature feature = (FT_Feature) iter.next();      
                result.getClass().getMethod("add", new Class[]{FT_Feature.class}).invoke(result,new Object[] {feature});
            }
	  	} catch (Exception e) {
	  		e.printStackTrace();
	  	}
	  } else {
		System.out.println("loadAllFeatures() : La classe passee en parametre n'est pas une sous-classe de FT_Feature");
	  }
	  return result;
    }
    



	/////////////////////////////////////////////////////////////////////////////////////////
	///// OQL ///////////////////////////////////////////////////////////////////////////////
	/////////////////////////////////////////////////////////////////////////////////////////                    
    /** Execute la requete OQL query, la lie avec le parametre param, et met le resultat dans une liste.
        A appeler a l'interieur d'une transaction ouverte.  
        On peut passer null pour param, si on ne souhaite lier la requete a aucune variable. */
    public  List loadOQL(String query, Object param) {
        OQLQuery oqlQuery = _odmg.newOQLQuery();
        try {
            oqlQuery.create(query);
            oqlQuery.bind( param );
            DList result = (DList) oqlQuery.execute();        
            return result;
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }        

    /** Cree une requete OQL */
    public OQLQuery newOQLQuery() {
        return _odmg.newOQLQuery() ;
    }
    
    
        
    /////////////////////////////////////////////////////////////////////////////////////////
    ///// Metadonnees sur le mapping ////////////////////////////////////////////////////////
    /////////////////////////////////////////////////////////////////////////////////////////    
    /** Renvoie le tableau des metadonnees. */
    public List getMetadata() {
        return _metadataList;
    }
    
    /** Renvoie les metadonnees de la classe theClass. 
        theClass doit etre une classe definie dans le mapping.*/
    public Metadata getMetadata(Class theClass) {
        for (int i=0; i<_metadataList.size(); i++)
            if (theClass.getName().compareTo(((Metadata)_metadataList.get(i)).getClassName()) == 0)
                return (Metadata)_metadataList.get(i);
        System.out.println("La classe n'est pas dans le fichier de mapping : "+theClass.getName());
        return null;
    }
                
    /** Renvoie les metadonnees de la classe mappee avec la table theTable.
        theTable doit etre une table definie dans le mapping. 
        Si theTable est mappee avec plusieurs classes, en renvoie une. */
    public Metadata getMetadata(String theTable) {
        for (int i=0; i<_metadataList.size(); i++)
            if (((Metadata)_metadataList.get(i)).getTableName() != null)
                if (theTable.compareToIgnoreCase(((Metadata)_metadataList.get(i)).getTableName()) == 0)
                    return (Metadata)_metadataList.get(i);
        System.out.println("La table n'est pas dans le fichier de mapping : "+theTable);
        return null;
    }
    

               
    /////////////////////////////////////////////////////////////////////////////////////////
    ///// SQL ///////////////////////////////////////////////////////////////////////////////
    /////////////////////////////////////////////////////////////////////////////////////////
    /** Renvoie la connection JDBC sous-jacente. */
    public Connection getConnection() {
        return _conn;
    }        
            
    /** Execute une commande SQL.
        Cette commande ne doit pas renvoyer de resultat : INSERT, UPDATE, DELETE, mais pas SELECT. */
    public void exeSQL(String query) {
        try {
            Connection conn = getConnection();
            Statement stm = conn.createStatement();
            stm.executeQuery(query);
            stm.close();
            conn.commit();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }        
    
    /** Execute une requete et met les resultats dans une liste de tableau d'objets.
        Les tableaux ont la taille du nombre d'objets demandes dans le SELECT.
        Exemple d'utilisation du resultat : 
        <tt> List edges = db.exeSQLQuery("SELECT edgeID FROM tableName WHERE ..."). </tt>
        Pour recuperer le premier resultat :
        <tt> edgeId = ( (BigDecimal) ((Object[]) (edges.get(0)) )[0] ).intValue(); </tt>  */
    public List exeSQLQuery(String query) {
        List result = new ArrayList();
        try {
            Connection conn = getConnection();
            Statement stm = conn.createStatement();
            ResultSet rs = (ResultSet)stm.executeQuery(query);
            ResultSetMetaData rsmd = rs.getMetaData();
            int nbCol = rsmd.getColumnCount();
            while (rs.next()) {
                Object[] array = new Object[nbCol];
                for (int i=1; i<= nbCol; i++)
                    array[i-1] = rs.getObject(i);
                result.add(array);
            }                
            stm.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }          
    
       
       
    ///////////////////////////////////////////////////////////////////////////////////////////////////////////
    // getters ODMG ///////////////////////////////////////////////////////////////////////////////////////////
    /////////////////////////////////////////////////////////////////////////////////////////////////////////// 
    public Implementation getODMGImplementation() {
    	return _odmg;
    }
   
	public Database getODMGDatabase() {
    	return _db;
    }
    
	public Transaction getODMGTransaction() {
    	return _tx;
    }
   	
}