Creato da pastuweb.com
Share My Page
My Social Accounts
Account FaceBook Account LinkedIn Account Twitter Account Google Plus Account Git Hub
Titolo progetto: Costruire un programma Java con relativo scanner JFlex e parser CUP per l'inserimento di dati "validati" all'interno di un database tramite un linguaggio ad-hoc di console.

Testo progetto:

Si implementi utilizzando, Jlex e Cup  per costruire un programma java per l'inserimento dati in un database di gestione ritardi ed uscite anticipate degli alunni di una scuola attraverso Linea di Comando.

In particolare si deve inventare un semplice linguaggio ed il relativo compilatore che permetta di:

  1. Autenticare l'utente utilizzatore (Login)
  2. Inserite attraverso 1 step un comando che dia indicazione sull'alunno, la classe, il tipo di operazione "ritardo/uscita anticipata", l'ora
  3. Visualizzare i ritardi e/o le uscite di un determinato alunno
  4. logout

Possibile Linguaggio:

User (u) o Login

Autenticazione: dovrebbe consentire l'immissione di user name e password

Logout

Effettua il logout

0data#Cognomealunno#nomealunno#classe#sezione#indirizzo#operazione#ora

Riga che contiene i dati da valicare e di cui fare il parsine

1

combinato con uno o pù dei parametri possibili riporta dati memorizzati nel db

es:

1#data

riporterà tutti le operazioni fatte per quella data

2#data#cognomealunno#nomealunno

a seguito di conferma permette di eliminare l'operazione indicata

 

dove

0                                     = Comando per l'inserimento

data                                = opzionale – se omessa rappresenta la data odierna

Cognomealunno             = cognome alunno

nomealunno                   = opzionale - da richiedere solo in casi di omonimi.

classe                           = anno di corso (1,2,3,4,5)

sezione                         = sezione (a,b,c,d,……)

indirizzo                        = Indirizzo di studi (scientifico industriale ….)

operazione                   = ingresso in ritardo, uscita anticipata

ora                               = opzionale- orario di ingresso o uscita se omesso ora attuale

Considerare un database con tre tabelle Alunni, Classe e OperazioniSi supponga che le tabelle Alunni e Classi siano già popolate.

Utilizzare db access o mysql indifferentemente.

Realizzare con una scelta una interfaccia che consenta la costruzione della linea di comando e la relativa esecuzione in maniera visuale.

Esempi di Input
Solo Autenticazione:
Login francesco
 
Comando 0 (inserimento):
0#21/10/2013#pasturenzi#francesco#anno di corso 1#sezione a#Indirizzo di studi polito#ingresso in ritardo#11:20
0#22/10/2013#clerico#anno di corso 2#sezione b#Indirizzo di studi torino#ingresso in ritardo#11:22
0#23/10/2013#ercoli#anno di corso 3#sezione a#Indirizzo di studi milano#ingresso in ritardo
0#24/10/2013#larini#giovanna#anno di corso 1#sezione a#Indirizzo di studi catania#uscita anticipata#12:20
0#pasturenzi#anno di corso 1#sezione d#Indirizzo di studi maxwell#ingresso in ritardo#15:20
 
Comando 1 (interrogazione):
1#22/10/2013
1#22/10/2013#pasturenzi#francesco
1#22/10/2013#pasturenzi#anno di corso 1#sezione a#Indirizzo di studi catania#ingresso in ritardo#11:20
1#22/10/2013#clerico#sezione b#Indirizzo di studi polito#ingresso in ritardo#10:20
1#anno di corso 2#sezione a#Indirizzo di studi milano
 
Comando 2 (interrogazione):
2#22/10/2013#pasturenzi#francesco
 
Tutto insieme: (unico test)
0#22/10/2013#pasturenzi#francesco#anno di corso 1#sezione a#Indirizzo di studi polito#ingresso in ritardo#11:20
0#22/10/2013#pasturenzi#anno di corso 1#sezione a#Indirizzo di studi polito#ingresso in ritardo#11:20
0#22/10/2013#pasturenzi#anno di corso 1#sezione a#Indirizzo di studi polito#ingresso in ritardo
0#22/10/2013#pasturenzi#francesco#anno di corso 1#sezione a#Indirizzo di studi polito#ingresso in ritardo#11:20
0#pasturenzi#anno di corso 1#sezione a#Indirizzo di studi polito#ingresso in ritardo#11:20
1#22/10/2013
1#22/10/2013#pasturenzi#francesco
1#22/10/2013#pasturenzi#anno di corso 1#sezione a#Indirizzo di studi polito#ingresso in ritardo#11:20
1#22/10/2013#pasturenzi#sezione a#Indirizzo di studi polito#ingresso in ritardo#11:20
1#anno di corso 1#sezione a#Indirizzo di studi polito
2#22/10/2013#pasturenzi#francesco
 
Codice JFlex: scanner.jflex
 
import java_cup.runtime.*;
 
%%
 
%class scanner
%unicode
%cup
%line
%column
 
%{
    private Symbol symbol(int type){
        return new Symbol(type, yyline, yycolumn);
    }
    private Symbol symbol(int type, Object value){
        return new Symbol(type, yyline, yycolumn, value);
    }
%}
 
stringa = [A-Za-z]+
classe = "anno di corso "[1-5]
sezione = "sezione "[a-z]
operazione = "ingresso in ritardo" | "uscita anticipata"
indirizzo = "Indirizzo di studi "{stringa}
ora = (((0|1)[0-9])|(2[0-3]))":"([0-5][0-9])
data = ((0[1-9])|([1-2][0-9])|(3(0|1)))"/"((0[1-9])|(1(0|1|2)))"/"(2[0-9][0-9][0-9])
 
%%
 
"User"              {return symbol(sym.USER);}
"u"                 {return symbol(sym.U);}
"Login"             {return symbol(sym.LOGIN);}
"Logout"            {return symbol(sym.LOGOUT);}
"0"                 {return symbol(sym.ZERO);}
"1"                 {return symbol(sym.UNO);}
"2"                 {return symbol(sym.DUE);}
"#"                 {return symbol(sym.SEP);}
 
{data}              {return symbol(sym.DATA, new String(yytext()));}
{ora}               {return symbol(sym.ORA, new String(yytext()));}
{operazione}        {return symbol(sym.OPERAZIONE, new String(yytext()));}
{classe}            {return symbol(sym.CLASSE, new String(yytext()));}
{sezione}           {return symbol(sym.SEZIONE, new String(yytext()));}
{indirizzo}         {return symbol(sym.INDIRIZZO, new String(yytext()));}
{stringa}           {return symbol(sym.STRINGA, new String(yytext()));}
 
[ \n\r\t]       {;}
.               {System.out.println("SCANNER ERROR: "+yytext());}
 
Il codice riportato qui sopra è quello che rappresenta lo scanner del progetto. Praticamente serve a riconoscere i simboli e pezzi dei comandi digitati. Molto importante l'overrindig dei metodi symbol utilizzati poi all'interno del codice CUP (parser). Molto importante anche la digitura "%cup" e "import java_cup.runtime.*;", questo indica che il parser che prenderà i simboli in pancia per avviare un analisi sintattica e semantica è l'engine CUP.
 
Una volta scritto lo scanner possiamo generare la classe Java: scanner.java e sym.java.
Comandi:
jflex scanner.jflex
crea lo scanner.java all'interno della cartella in cui è presente scanner.jflex
 
 
Codice CUP: parser.cup
CUP serve per parserizzare il contenuto dell'input passato allo scanner. L'input viene controllato sintatticamente e semanticamente.
Il parser controlla soltanto. Una volta che l'input è stato controllato dal parser si può poi adoperare per creare un output utile (questo viene fatto dal programma Java che si interfaccia con JDBC al database MySQL).
 
Ho anche aggiunto un controllo minimale sugli errori sintattici (non semantici).
 
import java_cup.runtime.*;
import java.io.*;
import java.util.*;
 
init with {:
System.out.println("PARSERRIZZO...");
:};
 
parser code {:
 
public static int flagLogin = 0;//usata nel Main del programma Java, a livello di classe, è statica
public static int flagLogout = 0;//usata nel Main del programma Java, a livello di classe, è statica
 
//la variabile isCorrect e l'oggetto comandoDigitato le uso poi nel Main del programma Java, stessa cosa per codCom e dataVuota
public int codCom = -1;//a livello di istanza
public int dataVuota = 0;//a livello di istanza
public int isCorrect = 0; //a livello di istanza
public Comando comandoDigitato = null; //a livello di istanza
 
//ritorna il valore semantico che cè all'interno dello stack ad una certa posizione, usato all'interno delle action delle regole CUP
//utile quando devo recuperare il valore di un simbolo Terminale o Non Terminale perchè magari devo salvarlo nel oggetto di supporto: "comandoDigitato"
//oppure perchè semplicemente devo stamparlo a schermo
public Object stack(int position) {
        return (((Symbol)stack.elementAt(tos+position)).value);
}
 
:};
 
action code {:
 
int flagDebug = 0;
private void stampa(String s){ 
        if (flagDebug == 1){
            System.out.println(s);           
        }
}
:};
 
//Terminal tokens: riconosciuti dallo scanner, il contenuto lo ricavo grazie alla classe Sym
terminal String DATA;
terminal String ORA;
terminal String OPERAZIONE;
terminal String CLASSE;
terminal String SEZIONE;
terminal String INDIRIZZO;
terminal String STRINGA;
terminal USER, U, LOGOUT, LOGIN,  SEP, ZERO, UNO, DUE;
 
//NON Terminal tokens: servono per creare la sintassi, vengono mescolati tra loro e con i simboli Terminali
non terminal progr;
non terminal logins, comandi, comando;
non terminal String datas;
non terminal String strs;
non terminal String clases;
non terminal String seziones;
non terminal String indirizzos;
non terminal String operaziones;
non terminal String oras;
 
// Precedences and associativities:
//molto importante e utilizzato principalmente quando ci sono ambiguità tra regole che differiscono di un solo simbolo terminale o non terminale seguito da SEP
// lower precedences
precedence left SEP;
// higher precedences
 
//////////////////////////////////////
// Grammar start
//////////////////////////////////////
 
start with progr
;
 
progr ::= logins {: stampa("OK, FINE PARSER!"); :}  
| comandi {: stampa("OK, FINE DEL PARSER !!!"); :} 
| LOGOUT {: 
parser.flagLogin = 0;
parser.flagLogout = 1;
stampa("OK, FINE DEL PARSER !!!"); 
:}  
| error {: stampa("Controllare la sintassi: u <user> <password>, User <user> <password>, Login <user> <password> oppure 0# | 1# | 2#"); :}
;
 
//ci si può loggare in 3 modi, quindi 3 regole distinte con action uguali
//si poteva anche creare un altro simbolo Non Terminale così da non duplicare il codice delle action
//MA dovevo rivedere le regole del simbolo Non Terminale "strs" usato nelle regole "comando"
//ci sarebbero stati dei problemi di ambiguità
logins ::= LOGIN STRINGA:ut STRINGA:ps {: 
 
String user = new String(ut);
String pass = new String(ps);
if( user.equals("sebastiano") && pass.equals("password") ){
parser.flagLogin = 1;
stampa("debug: Autenticazione con LOGIN.");
}else if(user.equals("francesco") && pass.equals("password") ){
parser.flagLogin = 1;
stampa("debug: Autenticazione con LOGIN.");
}
 
:} 
 
            | USER STRINGA:ut STRINGA:ps {: 
 
String user = new String(ut);
String pass = new String(ps);
if( user.equals("sebastiano") && pass.equals("password") ){
parser.flagLogin = 1;
stampa("debug: Autenticazione con USER.");
}else if(user.equals("francesco") && pass.equals("password") ){
parser.flagLogin = 1;
stampa("debug: Autenticazione con USER.");
}
 
:} 
 | U STRINGA:ut STRINGA:ps {: 
 
String user = new String(ut);
String pass = new String(ps);
if( user.equals("sebastiano") && pass.equals("password") ){
parser.flagLogin = 1;
stampa("debug: Autenticazione con U.");
}else if(user.equals("francesco") && pass.equals("password") ){
parser.flagLogin = 1;
stampa("debug: Autenticazione con U.");
}
 
:}  
//gestione errori del autenticazione
| LOGIN STRINGA:ut error {: stampa("debug: Manca la password"); :} 
| USER STRINGA:ut error {: stampa("debug: Manca la password"); :} 
| U STRINGA:ut error {: stampa("debug: Manca la password"); :} 
| LOGIN error STRINGA:ps {: stampa("debug: Manca l'user"); :} 
| USER error STRINGA:ps {: stampa("debug: Manca l'user"); :} 
| U error STRINGA:ps {: stampa("debug: Manca l'user"); :} 
;
            
comandi ::= comando {: 
if(parser.codCom == 1 && parser.dataVuota == 1){
parser.comandoDigitato.data = "none";
}
      :} 
      | comandi comando {:
if(parser.codCom == 1 && parser.dataVuota == 1){
parser.comandoDigitato.data = "none";
}
   :}
;
 
//regole per il riconoscimento dei comandi. Nelle actions viene riempito l'oggetto "comandoDigitato" usato poi nel Main del programma Java.
comando ::= ZERO SEP datas:dt STRINGA:cogn SEP strs:nome CLASSE:cla SEP SEZIONE:sez SEP INDIRIZZO:ind SEP OPERAZIONE:oper {: 
GregorianCalendar gc = new GregorianCalendar();
int ore = gc.get(Calendar.HOUR_OF_DAY);
int min = gc.get(Calendar.MINUTE);
String orario = new String(""+ore+":"+min);
 
//DATA
stampa("debug: "+dt);
//COGNOME
stampa("debug: "+cogn);
//NOME
stampa("debug: "+nome);
//CLASSE
stampa("debug: "+cla);
//SEZIONE
stampa("debug: "+sez);
//INDIRIZZO
stampa("debug: "+ind);
//OPERAZIONE
stampa("debug: "+oper);
//ORA
stampa("debug: ora assente, quindi OGGI: "+ore + ":" + min); 
 
parser.isCorrect = 1;
parser.comandoDigitato = new Comando(new String("INSERT"),
new String(dt),
new String(cogn),
new String(nome),
new String(cla),
new String(sez),
new String(ind),
new String(oper),
new String(orario)
);
parser.codCom = 0;
stampa("COMANDO ZERO\n\n"); 
 
:} 
 
            | ZERO SEP datas:dt STRINGA:cogn SEP strs:nome CLASSE:cla SEP SEZIONE:sez  SEP INDIRIZZO:ind  SEP OPERAZIONE:oper SEP oras:ora  {:
//DATA
stampa("debug: "+dt);
//COGNOME
stampa("debug: "+cogn);
//NOME
stampa("debug: "+nome);
//CLASSE
stampa("debug: "+cla);
//SEZIONE
stampa("debug: "+sez);
//INDIRIZZO
stampa("debug: "+ind);
//OPERAZIONE
stampa("debug: "+oper);
//ORA
stampa("debug: "+ora);
 
parser.isCorrect = 1;
parser.comandoDigitato = new Comando(new String("INSERT"),
new String(dt),
new String(cogn),
new String(nome),
new String(cla),
new String(sez),
new String(ind),
new String(oper),
new String(ora)
);
parser.codCom = 0;
stampa("COMANDO ZERO\n\n");
:} 
            | UNO  SEP datas:dt strs:stringa clases:cla seziones:sez indirizzos:ind operaziones:oper oras:ora {:
//DATA
stampa("debug: "+dt);
 
//COGNOME eo NOME
stampa("debug: "+stringa);
String[] temp;
temp = stringa.split(" ");
 
//CLASSE
stampa("debug: "+cla);
//SEZIONE
stampa("debug: "+sez);
//INDIRIZZO
stampa("debug: "+ind);
//OPERAZIONE
stampa("debug: "+oper);
//ORA
stampa("debug: "+ora);
 
 
parser.isCorrect = 1;
parser.comandoDigitato = new Comando(new String("SELECT"),
new String(dt),
new String(temp[0].toString()),
new String(temp[1].toString()),
new String(cla),
new String(sez),
new String(ind),
new String(oper),
new String(ora)
);
 
parser.codCom = 1;
stampa("COMANDO UNO\n\n");
:} 
            | DUE  SEP DATA:dt  SEP STRINGA:cogn  SEP STRINGA:nome {: 
//DATA
stampa("debug: "+dt);
//COGNOME
stampa("debug: "+cogn);
//NOME
stampa("debug: "+nome);
 
 
 
parser.isCorrect = 1;
parser.comandoDigitato = new Comando(new String("DELETE"),
new String(dt),
new String(cogn),
new String(nome));
 
stampa("COMANDO DUE\n\n"); 
:}
;
 
datas ::= DATA:dt SEP {:RESULT = new String(dt);:} 
| DATA:dt {:RESULT = new String(dt);:} 
| {: 
GregorianCalendar gc = new GregorianCalendar();
int anno = gc.get(Calendar.YEAR);
int mese = gc.get(Calendar.MONTH) + 1;
int giorno = gc.get(Calendar.DATE);
 
System.out.println("data assente, quindi OGGI: "+giorno + "/" + mese + "/" + anno); 
RESULT = new String( (""+giorno + "/" + mese + "/" + anno) );
 
//variabile di supporto, mi semplifica di molto il parser. Mi evita di gestire ambiguità dei comandi.
parser.dataVuota = 1;
:}
 
strs ::=  STRINGA:stringa1 SEP STRINGA:stringa2 SEP {:RESULT = new String(""+stringa1+" "+stringa2);:} 
| STRINGA:stringa1 SEP STRINGA:stringa2  {:RESULT = new String(""+stringa1+" "+stringa2);:} 
| STRINGA:stringa SEP  {:RESULT = new String(""+stringa+" none");:} 
| STRINGA:stringa {:RESULT = new String(""+stringa+" none");:}  
| {:RESULT = new String("none none");:}
;
 
clases ::= CLASSE:cl SEP  {:RESULT = new String(cl);:} 
| CLASSE:cl  {:RESULT = new String(cl);:} 
| {:RESULT = new String("none");:}
;
 
seziones ::= SEZIONE:sez SEP  {:RESULT = new String(sez);:} 
| SEZIONE:sez   {:RESULT = new String(sez);:} 
| {:RESULT = new String("none");:}
;
 
indirizzos ::= INDIRIZZO:ind SEP  {:RESULT = new String(ind);:}
| INDIRIZZO:ind  {:RESULT = new String(ind);:}
| {:RESULT = new String("none");:}
;
 
operaziones ::= OPERAZIONE:oper SEP  {:RESULT = new String(oper);:}
| OPERAZIONE:oper {:RESULT = new String(oper);:}
| {:RESULT = new String("none");:}
;
 
oras ::=  ORA:ora {:RESULT = new String(ora);:}
| {:RESULT = new String("none");:}
;
 
Una volta scritto il parser possiamo generare la classe Java: parser.java.
Comandi:
java java_cup.Main parser.cup
crea il parser.java all'interno della cartella in cui è presente parser.cup
 
Una domanda che potrebbe venire è:
Il parser serve solo per controllare. Perchè inserire i valori dell'input in delle variabili e oggetti usati poi all'esterno del parser (metodo Main del programma Java) ????
Per semplicità. Infatti avrei potuto scannerizzare e parserizzare il comando in input e dare un semplice feedback(CORRETTO o NON CORRETTO) e poi direttamente nel Main prendermi i valori passati. Bastava splittare l'input sul separatore "#", memorizzare il tutto in un array e poi gestire l'output.
PERO' visto che parserizzo ed entro nel dettaglio di ogni comando e token perchè non prendere già i valori,? Infatti è quello che ho fatto, è una cosa in meno da fare nel Main.
 
 
Progetto Java: testa lo scanner e il parser e si interfaccia con il database tramite JDBC.
Il progetto di test contiene:
  • Comando.java
  • Database.java
  • Main.java
  • parser.java
  • scanner.java
  • sym.java

JAR inclusi nel Build Path:

  • java-cup-0.11a.jar
  • mysqlo-connector-java-5.1.7-bin.jar

Andaiamo in oridine:

Codice Comando.java: usato all'interno del parser.cup per memorizzare i valori di input poi fruiti nel Main.java
class Comando {
public String tipoComando;
public String data;
public String cognome;
public String nome;
public String classe;
public String sezione;
public String indirizzo;
public String operazione;
public String ora;
 
Comando(String tipoComando, String data,  String cognome, String nome, String classe,
String sezione, String indirizzo, String operazione, String ora){
this.tipoComando = tipoComando.toString();
this.data = data.toString();
this.cognome = cognome.toString();
this.nome = nome.toString();
this.classe = classe.toString();
this.sezione = sezione.toString();
this.indirizzo = indirizzo.toString();
this.operazione = operazione.toString();
this.ora = ora.toString();
}
 
Comando(String tipoComando, String data,  String cognome, String nome){
this.tipoComando = tipoComando.toString();
this.data = data.toString();
this.cognome = cognome.toString();
this.nome = nome.toString();
}
}
 
 
Codice Database.java: usato all'interno Main.java per interfacciarsi con il database
 
import java.sql.*;
import java.util.Vector;
/**
 * Classe che rappresenta una connessione al database. 
 * Contiene i metodi per eseguire query di consultazione o di aggiornamento.
 * Contiene inoltre i metodi per connettersi/disconnettersi al database.
 * 
 */
public class Database {
 
private String DBname;
private String passwd;
private String user;
private String host;
private boolean connected;
private Connection conn;
 
/**
* Costruttore di classe
* @param DBname il nome del database
* @param passwd la password di accesso
* @param user il nome utente
* @param host l'indirizzo del server
*/
public Database(String DBname, String passwd, String user,String host)
{
this.DBname = DBname;
this.passwd = passwd;
this.user = user;
this.host = host;
connected = false;
}
 
/**
 * Permette di connettersi al database selezionato
 * 
 */
public boolean connect() {
   connected = false;
   try {
 
      Class.forName("com.mysql.jdbc.Driver");
 
      if (!DBname.equals("")) {
         if (user.equals("")) {
            conn = DriverManager.getConnection("jdbc:mysql://localhost/" + DBname);
         } else {
 
            if (passwd.equals("")) {
               conn = DriverManager.getConnection("jdbc:mysql://localhost/" + DBname + "?user=" + user);
            } else {
               conn = DriverManager.getConnection("jdbc:mysql://localhost/" + DBname + "?user=" + user + "&password=" + passwd);
            }
         }
         connected = true;
      } else {
         System.out.println("Manca il nome del database!!");
         System.out.println("Scrivere il nome del database da utilizzare all'interno del file \"config.xml\"");
         System.exit(0);
      }
   } catch (Exception e) {e.getMessage(); }
   return connected;
}
 
/**
 * Esegue Query per la consultazione dei dati presenti nel database
 * 
 */
public boolean executeQuery(String query, String tabella, String metodo) {
    
boolean result = false;
    try {
       Statement stmt = conn.createStatement();    
       ResultSet rs = stmt.executeQuery(query);   
       
       if(tabella.equalsIgnoreCase("alunni")){
      
      if(metodo.equalsIgnoreCase("viewIdNomeCognome")){
      
      while (rs.next()) {
      String id = rs.getString("id");
      String nome = rs.getString("nome");
      String cognome = rs.getString("cognome");
      System.out.printf("alunno: %s %s %s \n", id, nome, cognome);
      }
   
      }else if(metodo.equalsIgnoreCase("viewId")){
      
      while (rs.next()) {
      String id = rs.getString("id");
      System.out.printf("id_alunno: %s \n", id);
      }
      
      }
 
       }else if(tabella.equalsIgnoreCase("scuola")){
      
      if(metodo.equalsIgnoreCase("viewIdClasseSezione")){
          
      while (rs.next()) {
      String id = rs.getString("id");
      String classe = rs.getString("classe");
      String sezione = rs.getString("sezione");
      System.out.printf("info scuola: %s %s %s \n", id, classe, sezione);
      }
   
      }else if(metodo.equalsIgnoreCase("viewId")){
      
      while (rs.next()) {
      String id = rs.getString("id");
      System.out.printf("id_scuola: %s \n", id);
      }
      
      }
      
       }else if(tabella.equalsIgnoreCase("operazioni")){
      
      if(metodo.equalsIgnoreCase("viewIdOperazioneDataOra")){
          
      while (rs.next()) {
      String id = rs.getString("id");
      String operazione = rs.getString("operazione");
      String data = rs.getString("data");
      String ora = rs.getString("ora");
      System.out.printf("operazione: %s %s %s %s \n", id, operazione, data, ora);
      }
   
      }else if(metodo.equalsIgnoreCase("viewId")){
      
      while (rs.next()) {
      String id = rs.getString("id");
      System.out.printf("id_operazione %s \n", id);
      }
      
      }
      
       }
       
       result = true;
       rs.close();    
       stmt.close();   
    } catch (Exception e) { e.printStackTrace(); e.getMessage(); }
 
    return result;
 }
 
 
/**
 * Esegue altre Query ad-hoc
 * 
 */
public int getIdAlunno(String nome, String cognome){
int id = -1;
 
Statement stmt;
ResultSet rs;
String query = null;
try {
stmt = conn.createStatement();
 
if(nome != null && cognome != null){
query = "SELECT id FROM alunni WHERE nome = \""+nome+"\" and cognome = \""+cognome+"\"";
rs = stmt.executeQuery(query);
while (rs.next()) {
     id = rs.getInt("id");
}
}else{
id = -1;
}
    
    
} catch (SQLException e) {
e.printStackTrace();
}    
 
return id;
}
 
public int getIdScuola(String classe, String sezione){
int id = -1;
 
Statement stmt;
ResultSet rs;
String query = null;
try {
stmt = conn.createStatement();
 
if(classe != null && sezione != null){
query = "SELECT id FROM scuola WHERE classe = \""+classe+"\" and sezione = \""+sezione+"\"";
rs = stmt.executeQuery(query);
while (rs.next()) {
     id = rs.getInt("id");
}
}else{
id = -1;
}
    
    
} catch (SQLException e) {
e.printStackTrace();
}    
 
return id;
}
 
public void viewAllOperazioni(String data, String operazione, String ora, String cognome, String nome){
 
Statement stmt;
ResultSet rs;
String query = null;
try {
stmt = conn.createStatement();
 
if(data != null && operazione != null && ora != null && cognome != null && nome != null ){
query = "SELECT operazioni.id, nome, cognome, data, ora, operazione FROM operazioni, alunni WHERE
operazioni.id_alunno=alunni.id and data = \""+data+"\" and ora = \""+ora+"\" and nome = \""+nome+"\"
and cognome = \""+cognome+"\" and operazione = \""+operazione+"\"";
rs = stmt.executeQuery(query);
while (rs.next()) {
   
System.out.printf("operazione: %s %s %s %s %s %s \n", rs.getString("id"), rs.getString("nome"),
rs.getString("cognome"), rs.getString("data"), rs.getString("ora"), rs.getString("operazione"));
 
}
}else if(data != null && operazione != null && ora != null && cognome != null && nome == null ){
query = "SELECT operazioni.id, nome, cognome, data, ora, operazione FROM operazioni, alunni WHERE
operazioni.id_alunno=alunni.id and data = \""+data+"\" and ora = \""+ora+"\" and cognome = \""+cognome+"\" and operazione = \""+operazione+"\"";
rs = stmt.executeQuery(query);
while (rs.next()) {
   
System.out.printf("operazione: %s %s %s %s %s %s \n", rs.getString("id"), rs.getString("nome"),
rs.getString("cognome"), rs.getString("data"), rs.getString("ora"), rs.getString("operazione"));
 
}
}else if(data != null && operazione != null && ora != null ){
query = "SELECT operazioni.id, nome, cognome, data, ora, operazione FROM operazioni, alunni WHERE
operazioni.id_alunno=alunni.id and data = \""+data+"\" and ora = \""+ora+"\" and operazione = \""+operazione+"\"";
rs = stmt.executeQuery(query);
while (rs.next()) {
   
System.out.printf("operazione: %s %s %s %s %s %s \n", rs.getString("id"), rs.getString("nome"),
rs.getString("cognome"), rs.getString("data"), rs.getString("ora"), rs.getString("operazione"));
 
}
}else if(data != null && ora != null ){
query = "SELECT operazioni.id, nome, cognome, data, ora, operazione FROM operazioni, alunni WHERE operazioni.id_alunno=alunni.id and data = \""+data+"\" and ora = \""+ora+"\" ";
rs = stmt.executeQuery(query);
while (rs.next()) {
   
System.out.printf("operazione: %s %s %s %s %s %s \n", rs.getString("id"), rs.getString("nome"), rs.getString("cognome"), rs.getString("data"), rs.getString("ora"), rs.getString("operazione"));
 
}
}else if(data != null && ora != null && cognome != null && nome != null ){
query = "SELECT operazioni.id, nome, cognome, data, ora, operazione FROM operazioni, alunni WHERE operazioni.id_alunno=alunni.id and data = \""+data+"\" and ora = \""+ora+"\" and nome = \""+nome+"\" and cognome = \""+cognome+"\" ";
rs = stmt.executeQuery(query);
while (rs.next()) {
   
System.out.printf("operazione: %s %s %s %s %s %s \n", rs.getString("id"), rs.getString("nome"), rs.getString("cognome"), rs.getString("data"), rs.getString("ora"), rs.getString("operazione"));
 
}
}
    
    
} catch (SQLException e) {
e.printStackTrace();
}    
 
}
 
 
/**
 * Esegue una query di aggiornamento del database
 */
public boolean executeUpdate(String query) {
   int num = 0;
   boolean result = false;
   try {
      Statement stmt = conn.createStatement();
      num = stmt.executeUpdate(query);
      result = true;
      stmt.close();
   } catch (Exception e) {
      e.printStackTrace();
      e.getMessage();
      result = false;
   }
   return result;
}
 
/**
 * Esegue la disconnessione dal database
 */
public void disconnect() {
   try {
      conn.close();
      connected = false;
   } catch (Exception e) { e.printStackTrace(); }
}
 
/**
 * Ottiene l'oggetto Connection associato a questo database
 */
public Connection getConnection()
{
return conn;
}
 
/**
 * Indica se la connessione se è attiva
 */
public boolean isConnected()
{
return this.connected;
}
 
}
 
Codice Main.java: classe per testare il funzionamento del parser, scanner e output dell'input inserito.
 
import java.io.*;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
import java.util.Vector;
 
 
public class Main {
    static public void main(String argv[]) throws InterruptedException, IOException {    
        
    String intestazione = "################################# Progetto JFlex/CUP/Java/JDBC #############################################################\n\n"+
"Comandi di Autenticazione:\n\n"+
">>>Login <utente> <passwd> or u <utente> <password> or User <utente> <password>\n"+
">>>Logout\n\n"+
"Comandi per interagire con il database:\n"+
">>>0#[<data>]#<cognomealunno>#[<nomealunno>]#<classe>#<sezione>#<indirizzo>#<operazione>#[<ora>] ----> INSERT su DB\n"+
">>>1#[<data>]#[<cognomealunno>]#[<nomealunno>]#[<classe>]#[<sezione>]#[<indirizzo>]#[<operazione>]#[<ora>] ----> SELECT su DB\n"+
">>>2#<data>#<cognomealunno>#<nomealunno> ----> DELETE su DB\n\n"+
"Importante: descrizione dei parametri dei comandi e valori possibili:\n"+
"[<campo>]: opzionalità\n"+
"<campo>: obbligatorio\n"+
"classe = \"anno di corso <numero tra 1 e 5>\" \n"+
"sezione = \"sezione <carattere tra a e z>\" \n"+
"indirizzo = \"Indirizzo di studi <stringa>\" \n"+
"operazione = \"ingresso in ritardo\" | \"uscita anticipata\" \n"+
"orario nel formato hh:mm \n"+
"data nel formato gg/mm/aaaa \n\n"+
"##########################################################################################################";
   
    Scanner input = new Scanner(System.in);
    String strComando=null;
    scanner l = null;
    parser p = null;
    int login = 0;
    int logout = 0;
   
    System.out.println(intestazione);
   
    //connessione al Database
    Database db = new Database("databaseprogetto","","root","localhost");
    if(db.connect()){
    System.out.println("Connessione al Database ESEGUITA.");
    System.out.println("TEST Query:");
    db.executeQuery("SELECT id, nome, cognome FROM alunni", "alunni", "viewIdNomeCognome");
    }
   
    //PRIMA FASE: Autenticazione
    do{
    System.out.println("Digita comando di login:");
    System.out.print(">>> ");
    strComando = input.nextLine();
   
    try {
   
            l = new scanner(new java.io.StringReader(strComando));
               
           p = new parser(l);
           Object result = p.parse();//avvio il parser
 
       } catch (Exception e) {
           e.printStackTrace();
       }
   
    if(parser.flagLogin == 1){
    login = 1;
    }
   
    }while(login==0);
   
    //SECONDA FASE: codice SQL o Logout
    do {
        System.out.println("Digita un comando 0# | 1# | 2# | Logout:");
        System.out.print(">>> ");
        strComando = input.nextLine();
       
      try {
 
            l = new scanner(new java.io.StringReader(strComando));
               
           p = new parser(l);
           Object result = p.parse();//avvio il parser
 
    } catch (Exception e) {
           e.printStackTrace();
    }
 
  if(parser.flagLogout == 1){
  logout = 1;
  }else{
  //comandi #0, #1, #2
  //FASE TRE: interazione con il DB
  System.out.println("SQL generato:"+p.codCom);
 
  if(p.isCorrect == 1 && p.comandoDigitato.tipoComando.equals("SELECT") ){
System.out.println("SELECT");
 
System.out.println(""+p.comandoDigitato.data+"\n"+p.comandoDigitato.cognome+"\n"+p.comandoDigitato.nome+"\n"+
p.comandoDigitato.classe+"\n"+p.comandoDigitato.sezione+"\n"+p.comandoDigitato.indirizzo+"\n"+
p.comandoDigitato.operazione+"\n"+p.comandoDigitato.ora);
 
  //es: vedi tutte le operazioni di un utente
  if(!p.comandoDigitato.data.equalsIgnoreCase("none") && !p.comandoDigitato.ora.equalsIgnoreCase("none") &&
!p.comandoDigitato.nome.equalsIgnoreCase("none") && !p.comandoDigitato.cognome.equalsIgnoreCase("none")){
  db.viewAllOperazioni(p.comandoDigitato.data.toString(), null, p.comandoDigitato.ora.toString(),
p.comandoDigitato.cognome.toString(), p.comandoDigitato.nome.toString());
  }
 
 
    }else if(p.isCorrect == 1 && p.comandoDigitato.tipoComando.equals("INSERT") ){
System.out.println("INSERT");
 
System.out.println(""+p.comandoDigitato.data+"\n"+p.comandoDigitato.cognome+"\n"+p.comandoDigitato.nome+"\n"+
p.comandoDigitato.classe+"\n"+p.comandoDigitato.sezione+"\n"+p.comandoDigitato.indirizzo+"\n"+p.comandoDigitato.operazione+"\n"+p.comandoDigitato.ora);
 
  /* TO DO */
 
    }else if(p.isCorrect == 2 && p.comandoDigitato.tipoComando.equals("DELETE") ){
  System.out.println("DELETE");
 
    System.out.println(""+p.comandoDigitato.data+"\n"+p.comandoDigitato.cognome+"\n"+p.comandoDigitato.nome+"\n"+
p.comandoDigitato.classe+"\n"+p.comandoDigitato.sezione+"\n"+p.comandoDigitato.indirizzo+"\n"+
p.comandoDigitato.operazione+"\n"+p.comandoDigitato.ora);
  /*
  String operation = new String();
  operation = "DELETE FROM alunni WHERE nome = '"+p.comandoDigitato.nome.toString()+"' and cognome = '"+p.comandoDigitato.cognome.toString()+"'";
  System.out.println(operation);
  db.executeUpdate(operation);
  */
      }
 
  System.out.println("Esecuzione SQL ...");
  Thread.sleep(5000);
  System.out.println("\nSQL eseguito!\n");
       }
 
        
    }while(logout == 0);
        
    System.out.println("FINE PROGRAMMA.");
    System.exit(0);
   
    }
}
 
 
You can find this project on my GitHub Repository at this repository URL: https://github.com/pastuweb/jflex-cup-standalone-console
Average (1 Vote)
The average rating is 5.0 stars out of 5.