Ayuda con Analizador de Sentencias SQL ("select") en Java

Hola amigos...queria ver si no me echan una mano, con un proyecto para la universidad, la cosa es que con un archivo de entrada, en el cual van a estar las sentencias de SQL, en realidad solo la "select", pero son varias, asi:
select * from Facturas;
select code,nombre from Clientes;
pero tambien hay sentencias erroneas, para probar si el programa las detecta
select from Alumno
tambien tengo 2 archivos: uno llamado Facturas.txt y el otro Clientes.txt.
Entonces despues de revisar si la gramatica de las sentencias SQL estan correctas, se deben ejecuatar dichas sentencias correctas, de esta manera, por ejemplo en el archivo de entrada hay una linea asi:
select code,nombre from Clientes;
por lo cual se debe ir al archivo Clientes.txt y extraer las columnas code y nombre, para luego ser mostrados en pantalla....
les dejo un codigo que he estado haciendo...esta mal...pero con algo se empieza no???

package proyec_2;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.StringTokenizer;
import java.util.logging.Level;
import java.util.logging.Logger;
 
public class SQL
{
     ArrayList Abr = new ArrayList();
      ArrayList Abr2 = new ArrayList();
     ArrayList CL = new ArrayList();
     String s1,c,CC,ss2;
           String s2,Campo;
      ArrayList MTX = new ArrayList();
      ArrayList DAT = new ArrayList();
      ArrayList DT = new ArrayList();
      ArrayList DAT_to_Print = new ArrayList();
     String matrix[][]=new String[40][2];      
           String s,D;
           String SS;
           int id=0;
    public void AN_SQL() throws FileNotFoundException
    {
        // Cargamos el buffer con el contenido del archivo
try{
           BufferedReader br = new BufferedReader (new FileReader ("archivo_prueba.txt"));
 
           // Leemos la primera linea
 
           while((s1 = br.readLine())!=null){
 
//           System.out.println ("La primera linea del archivo es: " + s1);
//           System.out.println ("La linea tiene " + s1.length() + " caracteres");
//
//           System.out.println ();
//           System.out.println ("Separando la linea en trozos tenemos las siguientes palabras:");
 
           int numTokens = 0;
           StringTokenizer st = new StringTokenizer (s1,"+");
 
           // bucle por todas las palabras
           while (st.hasMoreTokens())
           {
               s2 = st.nextToken();
               Abr.add(s2);
               numTokens++;
               System.out.println ("    Palabra " + numTokens + " es: " + s2);
           }
 
           }} catch (IOException ex) {
                Logger.getLogger(Stream.class.getName()).log(Level.SEVERE, null, ex);
            }
        System.out.println("ABR "+Abr);
 
        }
 
    public void search() throws FileNotFoundException{
        String DATOS;
        for(int x=0;x<Abr.size();x++){
            if(Abr.get(x).equals("from")){
                System.out.println("Se encontro from "+Abr.get(x)+"  en la posicion: "+x);
 
                String Table= Abr.get(x+1).toString();
                int TmT=Table.length();
                String cortado;
                cortado = Table.substring(0,TmT-1);
                System.out.println("Cortado = "+cortado);
                Put_in_memory(cortado);
 
            }
        }
    }  
 
    //busqueda de Facturas
     public void search_F() throws FileNotFoundException{
        String DATOS="";
        for(int x=0;x<Abr.size();x++){
            if(Abr.get(x).equals("Facturas;")){
                System.out.println("Se encontro from "+Abr.get(x)+"  en la posicion: "+x);
               for(int y=0; y<Abr.size();y++)
                if(DATOS!="select"){
                    int t=x-1;
                    System.out.println("Datos --> "+t);//+DT);
                    DATOS=Abr.get(t).toString();
                    DT.add(DATOS);
                    t--;
               }
                System.out.println("Datos --> "+DT);
 
            }
        }
    }  
 
 
            public void search_Data(String data) throws FileNotFoundException{
        for(int x=0;x<MTX.size();x++){
            if(MTX.get(x).equals(data)){
                System.out.println("Se encontro Campos "+MTX.get(x)+"  en la posicion: "+x);
                int m=3;
                String Campos=(String) MTX.get(x+m);
                m=m+3;
                DAT_to_Print.add(Campos);
 
 
 
//                for(int y=0;y<MTX.size();y++){
//                
//            }
 
                //int TmT=Table.length();
                //String cortado;
                //cortado = Table.substring(0,TmT-1);
                //System.out.println("Cortado = "+cortado);
                //Put_in_memory(cortado);
            }
        }
        System.out.println("Dat_to_Print = "+DAT_to_Print);
    }
            public void search_After_Select() throws FileNotFoundException{
          // Cargamos el buffer con el contenido del archivo
//try{
//           BufferedReader br = new BufferedReader (new FileReader ("archivo_prueba.txt"));
//
//           // Leemos la primera linea
//          
//           while((s1 = br.readLine())!=null){
//
////           System.out.println ("La primera linea del archivo es: " + s1);
////           System.out.println ("La linea tiene " + s1.length() + " caracteres");
////
////           System.out.println ();
////           System.out.println ("Separando la linea en trozos tenemos las siguientes palabras:");
//
//           int numTokens = 0;
//            int numTokens2 = 0;
//           StringTokenizer st = new StringTokenizer (s1,"+,");
//
//           // bucle por todas las palabras
//           while (st.hasMoreTokens())
//           {
//               ss2 = st.nextToken();
//               Abr2.add(ss2);
//           }
//              
//           for(int a=0;a<Abr2.size();a++)
//           for(int f=0;f<MTX.size();f++)
//           for(int c=0;c<CL.size();c++)
//               if(Abr2.get(a).equals("*")){
//                 //  System.out.println("ASterisco");
//                  System.out.println ("    Asterisco " +" es: " +Abr2.get(a));
//               }
//               else if(Abr2.get(a).equals(MTX.get(f))){
//                   switch(id){
//                       case 0:
//                           System.out.println("ERROR EN CAMPOS Y/O TABLA factura");
//                       case 1:    
//                   //System.out.println("Datos...FAC----");
//                            System.out.println ("    Fac  es: " + MTX.get(f));
//                  
//               }
//               }else if(Abr2.get(a).equals(CL.get(c))){
//                   switch(id){
//                       case 0:
//                           System.out.println("ERROR EN CAMPOS Y/O TABLA clientes");
//                       case 1:    
//                   //System.out.println("Datos...FAC----");
//                            System.out.println ("    Clientes  es: " + CL.get(f));
//                  
//               }
//               }
//           }
//          
//           } catch (IOException ex) {
//                Logger.getLogger(Stream.class.getName()).log(Level.SEVERE, null, ex);
//            
//        System.out.println("ABR2 "+Abr2);
//           }
        }
 
    public void Put_in_memory(String name) throws FileNotFoundException{
        String nom=name+".txt";
        File n=new File(nom);
 
            if(!n.exists()){
            System.out.println("Error Tabla "+name +" no Existe!!!");
            }
            else{
        if(name.equals("Facturas")) {
            try {
                BufferedReader brs = new BufferedReader (new FileReader ("Facturas.txt"));
 
                   // Leemos la primera linea
 
                   while((s = brs.readLine())!=null){
                  // int numTokens = 0;
                   StringTokenizer st = new StringTokenizer (s,"+");
 
                   // bucle por todas las palabras
                   while (st.hasMoreTokens())
                   {
                       SS = st.nextToken();
                               MTX.add(SS);
 
 
                   }
                   id=1;
                   }
                    System.out.println("MTX "+MTX);
                    try{
           BufferedReader br = new BufferedReader (new FileReader ("archivo_prueba.txt"));
 
           // Leemos la primera linea
 
           while((s1 = br.readLine())!=null){
 
//           System.out.println ("La primera linea del archivo es: " + s1);
//           System.out.println ("La linea tiene " + s1.length() + " caracteres");
//
//           System.out.println ();
//           System.out.println ("Separando la linea en trozos tenemos las siguientes palabras:");
 
           int numTokens = 0;
            int numTokens2 = 0;
           StringTokenizer st = new StringTokenizer (s1,"+,");
 
           // bucle por todas las palabras
           while (st.hasMoreTokens())
           {
               ss2 = st.nextToken();
               Abr2.add(ss2);
           }
           }  
 
           for(int a=0;a<DT.size();a++)
           for(int f=0;f<3;f++)
         //  for(int c=0;c<CL.size();c++)
               switch(id){
                   case 0:
                       System.out.println("Error en Tabla y/o Campos no existentes");
                   case 1:
                       if(DT.get(a).equals("*")){
                         System.out.println("Asterisco--> "+DT.get(a));  
                       }else if(DT.get(a).equals(MTX.get(f))){
                         System.out.println("Campo Facts--> "+MTX.get(f));  
                       }
               }
 
           } catch (IOException ex) {
                Logger.getLogger(Stream.class.getName()).log(Level.SEVERE, null, ex);
 
        System.out.println("ABR2 "+Abr2);
           }
            }
 
            catch (IOException ex) {
                Logger.getLogger(Obtiene_Matriz_de_Archivo.class.getName()).log(Level.SEVERE, null, ex);
            }
           }else
        {System.out.println("Error en Tabla no existente");
         id=0;
        }
      if(name.equals("Clientes")) {
            try {
                BufferedReader brs = new BufferedReader (new FileReader ("Clientes.txt"));
 
                   // Leemos la primera linea
 
                   while((c = brs.readLine())!=null){
                  // int numTokens = 0;
                   StringTokenizer cl = new StringTokenizer (c,"+");
 
                   // bucle por todas las palabras
                   while (cl.hasMoreTokens())
                   {
                       CC = cl.nextToken();
                               CL.add(CC);
                               id=1;
 
                   }
                   }
                    System.out.println("clientes "+CL);
            }
 
            catch (IOException ex) {
                Logger.getLogger(Obtiene_Matriz_de_Archivo.class.getName()).log(Level.SEVERE, null, ex);
            }
           }else
        {System.out.println("Error en Tabla no existente");
         id=0;
        }
 
//       MTX.clear();
//       System.out.println("MTX "+MTX);
    }
    }
    public static void main (String[] args) throws FileNotFoundException
    {
        SQL OBM = new SQL();
        OBM.AN_SQL();
        OBM.search();
        OBM.search_F();
        OBM.search_After_Select();
 
    }
 
}

Opciones de visualización de comentarios

Seleccione la forma que prefiera para mostrar los comentarios y haga clic en «Guardar las opciones» para activar los cambios.

Y en que necesitas ayuda?

Y en que necesitas ayuda?

No leí muy a fondo tu código pero en vez de intentar escribir todo el código de una pasada intentando hacer todo el mismo tiempo, podrías dividirlo en dos partes grandes y esas dos partes en otras mas chicas. Así tu código seria mas sencillo.

Algo como esto

Parte 1: Validar la sentencia
Parte 2: Leer los datos

Parte 1

1. Leer la sentencia que vas a ejecutar ( leerla de la linea de comandos )
2.  Validar si empieza con "select" seguido de "algo" y luego tiene un "from"  y un nombre al final
2.1 Para eso lo puedes separar en tokens ( usando como separador el espacio en blanco y )
2.2 Válidas que el primero sea un "select" y que el penúltimo sea "from"
3. Sacar las dos cosas que te interesan de ese select, que son las "columnas" y la "tabla" y ponerlas en un objeto diferente.

Hasta ahi el "parseo" de la sentencia, sino cumple con eso no tiene caso continuar. Aun no validas si los campos existen o si la tabla ( el archivo ) existe, eso se deja a "tiempo de ejecucion"

Entonces seria algo como esto:

// programa principal
sentence = readSentence()
tokens = tokenize( sentence )
validate( tokens )
query  = createQueryFrom( tokens )
...
// funciones:

String readSentence() {
   return "select balbalabl from abalbabal" /// leerlo desde el teclado o pasarlo como argumento en la funcion main , etc.
}
String [] tokenize( String sentence ) {
   /// validar si es nulo, si tiene texto etc.
   if ( sentence is null   or is empty o blablaabl ) {
     throw IllegalArgumentExpception("No puede ser nulo, etc." );
  }
  return sentence.split("\\s," ) // buscar la expresion regular que represetnte espacio o comas
}
void validate( String [] tokens )  {
    //validar que tenga al menos 4 elementos, el select, una columna from y tabla
   if ( tokens[0] != "select" || tokens[length -2 ]  != "from"  || tokens.length != 4) {
     throw IllegalArgumentExpception("Sentencia invalida, se require blabalabla." );
   }
  // todo ok
}  

Query createQueryFrom( String [] tokens ) {
     Query query = new Query();
     query.columns = tokens.subarray(1, tokens.length -3 )  // subarray del segundo al antepenultimo
     query.table = tokens[length-1]
}
// Query es una clase como esta:
class Query {
   String[] columns
   String table
}

Parte 2.

Lo siguiente es ejecutarlo.
Ya tienes el query, ahora se necesita leer los datos.

4. Buscar el archivo: query.table +".txt"
4.1 Si no existe mandar excepcion
5. Leer la primera linea que debería de describir el nombre de las columnas, algo como como:
nombre|direccion|telefono|etc
6. Crear un objeto "metarow" o algo asi  con esa informacion y validar que el query tenga esas columas
6.1 Si no existe mandar excepcion
7. Leer linea por linea el archivo y guardarlo en un objeto row
8. Sacar de ese row solo las columnas que son interesantes
9. y ya

Algo como:

Row[] execute( Query query ) {  
   if ( ! file.exits( query.table + ".txt" ) ) {
      throw new IllegalArgumentException("table doesn't exists")
   }
  RowMetaData  metadata = null
  result = new Row[]
   for ( line in file.lines )  {
       if ( metadata == null ) {
           metadata = getMetadataFrom( line )  /// dividirlo por | y guardarlos en un arreglo
           if ( !metadata.fulfill( query ) { // ver que las columnas del query esten en el metadata
                throw new IllegalArgumentException("table doesn't exists")          
          }
     } else { /// a partir de la segunda linea
         result.add( new Row( query.getColumnsFrom(line)))
    }
    return result
}

Y pues ya, esa es la idea principal ( algo larga ). El caso es dividir la sentencia de la ejecución misma y separar las cosas en funciones tan pequeñas que puedan ser implementadas fácilmente. También la idea es utilizar objetos como estructuras de datos para guardar la informacion en vez de tener todo en arreglos.

Espero que esto te sirva