Advertisement
Guest User

Putin v1.2

a guest
Jun 11th, 2017
121
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Java 8.59 KB | None | 0 0
  1. package it.polito.db;
  2.  
  3. import java.sql.Connection;
  4. import java.sql.Date;
  5. import java.sql.DriverManager;
  6. import java.sql.PreparedStatement;
  7. import java.sql.ResultSet;
  8. import java.sql.SQLException;
  9. import java.sql.Statement;
  10. import java.util.Calendar;
  11. import java.util.LinkedList;
  12. import java.util.List;
  13.  
  14. public class DB {
  15.    
  16.     /* conn serve per "memorizzare" la connessione verso la base di dati */
  17.     private Connection conn;
  18.     private Statement stmt;
  19.     private ResultSet rs;
  20.    
  21.     /*
  22.      * Costruttore
  23.      */
  24.     public DB(){
  25.         /* Registrazione driver */
  26.         /* Si ricorda che la classe che implementa il Driver JDBC per oracle è
  27.          * oracle.jdbc.driver.OracleDriver */
  28.         try{Class.forName("oracle.jdbc.driver.OracleDriver");}
  29.         catch(Exception e){
  30.             System.err.println("\nDriver non disponibile: "+e);
  31.         }
  32.         /* Scrivere il pezzo di codice necessario per instanziare/registrare
  33.          * il driver Oracle che sarà utilizzato in seguito */
  34.        
  35.         /* Fine registrazione driver */
  36.     }
  37.    
  38.    
  39.     /*
  40.      * Metodo che apre la connessione con la base di dati.
  41.      * Ritorna true se la connessione viene aperta con successo, false altrimenti.
  42.      */
  43.     public boolean OpenConnection(){
  44.         try{
  45.             /* Aprire la connessione e salvarla nella variabile conn
  46.              * conn= ..... */
  47.             conn=DriverManager.getConnection("jdbc:oracle:thin:@127.0.0.1:1521:XE","SYSTEM","1234");
  48.             stmt=conn.createStatement();
  49.             return true;
  50.            
  51.         } catch(Exception ex){
  52.             ex.printStackTrace();
  53.             System.out.println("\nERR: connessione con il database non riuscita");
  54.             return false;
  55.         }
  56.  
  57.     }
  58.    
  59.  
  60.    
  61.     /*
  62.      * Questo metodo riceve in ingresso il codice di un cliente e
  63.      * ritorna i dati di tale cliente sottoforma di stringa.
  64.      * Praticamente la stringa restituita e' una concatenazione dei nomi
  65.      * degli attributi e dei suoi valori.
  66.      * Se ad esempio il cliente selezionato si chiama Paolo Garza, ha come indirizzo
  67.      * "Via Inesistente 24, Torino"
  68.      * e come numero di cellulare 0110907022 allora il metodo deve restituire
  69.      * la stringa "Nome: Paolo\nCognome: Garza\nIndirizzo: Via Inesistente 24, Torino\nCell: 0110907022"
  70.      */
  71.     public String ottieniDatiCliente(long codice_cliente) {
  72.        
  73.         String dati=null;
  74.         boolean clienteEsiste=true;
  75.         String Nome,Cognome,Indirizzo,Cell;
  76.         try {
  77.             rs=stmt.executeQuery("SELECT Nome,Cognome,Indirizzo,Cell"+
  78.                                 " FROM CLIENTE"+
  79.                                 " WHERE CLIENTE.CodiceCliente='"+codice_cliente+"'");
  80.             /* Eseguire l'interrogazione che reperisce dalla base di dati
  81.              * le informazioni relative al cliente con codice pari a quello
  82.              * presente nel parametro codice_cliente di questpo metodo */
  83.             if(rs.next()==false) clienteEsiste=false;
  84.            
  85.             /* Se il cliente esiste restituire la stringa con i suoi dati.
  86.              * Altrimenti una stringa contenente l'informazione "Cliente inestistente" */
  87.             if (clienteEsiste==true)
  88.             {
  89.                 /* Modificare il codice in modo da restituire i dati del cliente
  90.                  * ottenuti tramite l'esecuzione dell'interrogazione.
  91.                  * Usare lo stesso formato presente in questo esempio "statico"
  92.                  * per la formattazione della stringa di ritorno.
  93.                  * Gestire con attenzione le persone che non hanno un numero di
  94.                  * cellulare (il campo e' di tipo NULL)*/
  95.                 Nome=rs.getString("Nome");
  96.                 Cognome=rs.getString("Cognome");
  97.                 Indirizzo=rs.getString("Indirizzo");
  98.                 if((Cell=rs.getString("Cell"))==null){
  99.                     Cell="NULL";
  100.                 }
  101.                
  102.                 dati=new String("Nome: "+Nome+"\n"+
  103.                                 "Cognome: "+Cognome+"\n"+
  104.                                 "Indirizzo: "+Indirizzo+"\n"+
  105.                                 "Cell: "+Cell);
  106.             }
  107.             else
  108.             {
  109.                 /* Se il cliente non esiste restituisco un messaggio d'errore */
  110.                 dati=new String("Cliente inesistente");
  111.             }
  112.             rs.close();
  113.            
  114.         } catch (Exception e) {
  115.             e.printStackTrace();
  116.             return null;
  117.         }
  118.        
  119.         return dati;
  120.        
  121.     }
  122.    
  123.    
  124.    
  125.     /*
  126.      * Questo metodo ritorna una lista di stringhe. Ogni stringa contiene
  127.      * il nome di un corso. La lista di stringhe restituite corrisponde
  128.      * all'elenco di corsi cui e' iscritto il cliente con codice pari
  129.      * a quello presente nel parametro codice_cliente di questo metodo
  130.      */
  131.     public List<String> ottieniCorsiCliente(long codice_cliente) {
  132.         List<String> list=new LinkedList<String>();
  133.        
  134.         try {
  135.             rs=stmt.executeQuery("SELECT CodiceCorso"+
  136.                                  " FROM ISCRITTO_CORSO"+
  137.                                  " WHERE ISCRITTO_CORSO.CodiceCliente='"+codice_cliente+"'");
  138.             /* Inserire il pezzo di codice che accede alla base di
  139.              * dati e recupera i nomi del corsi cui e' iscritto
  140.              * il cliente con codice pari a quello presente
  141.              * nel parametro codice_cliente di questo metodo.
  142.              * Inserire i nomi dei corsi nella lista di stringhe restituita
  143.              * da questo metodo (ogni stringa della lista e' il nome di un corso)
  144.              * */
  145.            
  146.             while(rs.next()){
  147.             /* Esempio "statico" che restituisce sempre gli stessi nomi di corsi. */
  148.                 list.add(rs.getString("CodiceCorso"));
  149.             }
  150.             rs.close();
  151.         } catch (Exception e) {
  152.             e.printStackTrace();
  153.             return null;
  154.         }
  155.  
  156.         return list;
  157.     }
  158.    
  159.    
  160.    
  161.     /*
  162.      * Il metodo ritorna una lista di stringhe con dentro il codice dei corsi
  163.      * per cui c'e' ancora almeno un posto libero e i rispettivi nomi. Ogni stringa
  164.      * della lista restituita corrisponde ad un singolo corso e deve
  165.      * essere formattata usando il formato codice_corso - nome_corso
  166.      */
  167.     public List<String> ottieniCodiciCorsi() {
  168.         List<String> list=new LinkedList<String>();
  169.  
  170.         try {
  171.             rs=stmt.executeQuery("SELECT CodCorso,NomeC"+
  172.                                  " FROM CORSO"+
  173.                                  " WHERE CORSO.PostiDisponibili>=1");
  174.             /* Scrivere il pezzo di codice che reperisce le informazioni (codice e nome)
  175.              * per i corsi che hanno ancora posti disponibili (un corso ha ancora posti
  176.              * disponibili se l'attributo corso. postidisponibili e' maggiore o uguale
  177.              * a 1).
  178.              * Inserire nella lista una stringa per ogni corso restituito dall'interrogazione.
  179.              * */
  180.            
  181.             /* Esempio statico che restituisce sempre gli stessi corsi (fare attenzione
  182.              * al formato usato, ossia "codice_corso - nome_corso")*/
  183.             while(rs.next()){
  184.                 list.add(rs.getInt("CodCorso")+" - "+rs.getString("NomeC"));
  185.                 }
  186.             rs.close();
  187.            
  188.         } catch (Exception e) {
  189.             e.printStackTrace();
  190.             return null;
  191.         }
  192.  
  193.         return list;
  194.     }
  195.    
  196.    
  197.    
  198.     /*
  199.      * Questo metodo riceve in ingresso (parametri di input) il codice di un corso
  200.      * e il codice di un cliente e iscrive il cliente al corso (ossia
  201.      * aggiunge una nuova iscrizione nella base di dati). L'iscrizione
  202.      * consiste nell'inserimento della tupla appropriata nella tabella iscritto_corso.
  203.      *
  204.      * Una volta aggiunta l'iscrizione nella tabella iscritto_corso, il metodo
  205.      * viene aggiornare (decrementandolo di uno) il valore dei posti disponibili
  206.      * per il corso indicato in codCorso (praticamente di deve eseguire un'istruzione
  207.      * SQL di aggiornamento che vada a decrementare di uno il valore del
  208.      * campo corso.postidisponibili per il corso per cui si e' appena effettuata
  209.      * l'iscrizione).
  210.      *
  211.      * Il metodo ritorna true se l'iscrizione e' avvenuta correttamente, false altrimenti.
  212.      */
  213.     public boolean aggiungiIscrizione(long codCorso,long codCliente) throws SQLException{
  214.         try {
  215.             conn.setAutoCommit(false);
  216.                 /* Inserire il codice necessario per
  217.                  * 1 - inserire la nuova tupla nella tabella iscritto_corso, ossia quella relativa
  218.                  *     all'iscrizione del cliente con codice codCliente al corso con codice codCorso  
  219.                  * 2 - aggiornare il numero di posti disponibili (attributo corso.postidisponibili)
  220.                  *     per il corso con codice pari a codCorso.
  221.                  *    
  222.                  * Fare attenzione che le due operazioni devono andare entrambe a buon fine,
  223.                  * oppure essere annullate entrambe se una delle due fallisce (vedere
  224.                  * i lucidi sulla gestione delle le transazioni in JDBC)
  225.                  * */
  226.                 rs=stmt.executeQuery("INSERT INTO ISCRITTO_CORSO(CodiceCliente,CodiceCorso,DataIscrizione)"+
  227.                                      " VALUES('"+codCliente+"','"+codCorso+"','"+ "INSERIREDATA" +"'')");
  228.                 rs=stmt.executeQuery("UPDATE CORSO SET PostiDisponibili=PostiDisponibili-1 WHERE CodCorso='"+codCorso+"'");
  229.                
  230.                 conn.commit();
  231.                 conn.setAutoCommit(true);
  232.                 return true;
  233.         } catch (Exception e) {
  234.                 e.printStackTrace();
  235.                 conn.rollback();
  236.                 return false;
  237.         }
  238.  
  239.     }
  240.    
  241.    
  242.     /*
  243.      * Questo metodo chiude la connessione con il DB
  244.      */
  245.     public void CloseConnection(){
  246.         try {
  247.             stmt.close();
  248.             conn.close();
  249.             /* Scrivere il pezzo di codice che chiude la connessione con la base di dati */
  250.         } catch (Exception e) {
  251.             System.err.println("Errore nel chiudere la connessione con il DB!");
  252.         }
  253.     }
  254. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement