Import Wikipedia category graph

package importazione;

import java.io.BufferedReader;
import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Map;

import org.neo4j.graphdb.DynamicRelationshipType;
import org.neo4j.graphdb.index.BatchInserterIndex;
import org.neo4j.graphdb.index.BatchInserterIndexProvider;
import org.neo4j.graphdb.index.IndexHits;
import org.neo4j.helpers.collection.MapUtil;
import org.neo4j.index.impl.lucene.LuceneBatchInserterIndexProvider;
import org.neo4j.kernel.impl.batchinsert.BatchInserter;
import org.neo4j.kernel.impl.batchinsert.BatchInserterImpl;

public class importa {

    /**
     * @param args
     * @throws IOException
     */
        public static void main(String[] args) throws IOException {
        BatchInserter inserter = new BatchInserterImpl( "/media/Ubuntu/wikipedia/batchcreating" );
        BatchInserterIndexProvider indexProvider = new LuceneBatchInserterIndexProvider(inserter);
        BatchInserterIndex IDs = indexProvider.nodeIndex( "IDs", MapUtil.stringMap( "type", "exact" ) );
        BatchInserterIndex names = indexProvider.nodeIndex( "names", MapUtil.stringMap( "type", "exact" ) );


        IDs.setCacheCapacity( "ID", 100000 );
        names.setCacheCapacity( "name", 100000 );

        // BEFORE using this brogram is necessary to use the command sed 's/),(/\n/g' *.sql
        //on the two extracted .sql files
        Lettore l=new Lettore("/media/Ubuntu/wikipedia/enwiki-20110901-page.sql");


        boolean iniziato=false;
        for(String riga:l){
            if(!iniziato){
                if(riga.contains("INSERT INTO"))
                    iniziato=true;
                continue;

            }
            if (riga.contains("INSERT INTO `page` VALUES ("))
                riga=riga.substring("INSERT INTO `page` VALUES (".length());
            //mi interrompo se sono alla fine
            if (riga.startsWith("/*!40000 ALTER TABLE")) break;
            int ns=Integer.parseInt(riga.split(",")[1]);
            if (ns!=0 && ns!=14) continue;
            int id=Integer.parseInt(riga.split(",")[0]);
            String parte=riga.split(",'")[1];
            //la pagina sulla virgola darebbe problemi, basta identificarla con il suo id e trattarla a parte
            String nome;
            if (id==64494)
                nome=",";
            else
                nome=parte.substring(0,parte.length()-1);
            nome=nome.replace("\\'", "'");

            if (ns==0){
                //è una pagina
                //se è una disambiguazione la salto
                if(nome.contains("(disambiguation)")) continue;
                Map<String, Object> properties = MapUtil.map("name", nome,"ID",new Integer(id),"type","page" );
                long node = inserter.createNode( properties );
                IDs.add( node, MapUtil.map("ID",new Integer(id)));
                names.add( node, MapUtil.map("name",nome));
                System.out.println("pagina "+nome+"["+id+"]");
            }
            if (ns==14){
                //è una categoria
                //se è sicuramente non significativa, la salto
                if (nome.contains("_redirects")) continue;
                if (nome.contains("Articles_"))  continue;
                if (nome.contains("_articles")) continue;
                if (nome.contains("Pages_with_"))  continue;
                if (nome.contains("Redirects_"))  continue;
                if (nome.contains("_disambiguation_"))  continue;
                if (nome.contains("Disambiguation_"))  continue;
                if (nome.contains("Start-Class_"))  continue;
                Map<String, Object> properties = MapUtil.map("name", nome,"ID",new Integer(id),"type","cat" );
                long node = inserter.createNode( properties );
                IDs.add( node, MapUtil.map("ID",new Integer(id)));
                names.add( node, MapUtil.map("name",nome));
                System.out.println("categoria "+nome+"["+id+"]");
            }

        }
        l.chiudi();

        names.setCacheCapacity("name", 400000);



        l=new Lettore("/media/Ubuntu/wikipedia/enwiki-20110901-categorylinks.sql");


        iniziato=false;
        //mi servono per evitare di recuperare ogni volta lo stesso id
        int oldid=-1;
        IndexHits<Long> oldlista = null;

        for(String riga:l){

            if(!iniziato){
                if(riga.contains("INSERT INTO"))

                    iniziato=true;
                continue;

            }
            if (riga.contains("INSERT INTO `categorylinks` VALUES ("))
                riga=riga.substring("INSERT INTO `categorylinks` VALUES (".length());
            //mi interrompo se sono alla fine
            if (riga.startsWith("/*!40000 ALTER TABLE")) break;

            int id=Integer.parseInt(riga.split(",")[0]);
            String parte=riga.split(",'")[1];

            String nome=parte.substring(0,parte.length()-1);
            nome=nome.replace("\\'", "'");


            //se è sicuramente non significativa, la salto
            if (nome.contains("_redirects")) continue;
            if (nome.contains("Articles_"))  continue;
            if (nome.contains("_articles")) continue;
            if (nome.contains("Pages_with_"))  continue;
            if (nome.contains("Redirects_"))  continue;
            if (nome.contains("_disambiguation_"))  continue;
            if (nome.contains("Disambiguation_"))  continue;
            if (nome.contains("Start-Class_"))  continue;
            if (nome.contains("All_pages_"))  continue;
            if (nome.contains("Use_mdy_"))  continue;
            if (nome.contains("Unverifiable_"))  continue;
            if (nome.contains("-protected_pages"))  continue;
            if (nome.contains("semi-protected"))  continue;
            if (nome.contains("Pages_containing_"))  continue;
            if (nome.contains("_stubs"))  continue;


            //recupero l'elemento contenuto
            //se è quello di prima non ripeto il recupero
            IndexHits<Long> lista;
            if(id==oldid){
                lista=oldlista;
            }
            else{
                lista = IDs.get("ID", id);
                oldlista=lista;
                oldid=id;
            }

            //se la lista non è vuota, contiene un solo elemento
            if(lista.hasNext()){
                Long idelem = lista.next();
                //ora recupero la categoria che ha quel nome
                for(Long idcat:names.get("name", nome)){
                    //potrebbe essere una categoria o una pagina con lo stesso nome
                    if(inserter.getNodeProperties(idcat).get("type").equals("cat")){
                        //ho recuperato idcat e idelem, devo capire se idelem rappresenta una pagina o un'altra categoria
                        if(inserter.getNodeProperties(idelem).get("type").equals("cat")){
                            //è una categoria
                            inserter.createRelationship(idelem, idcat, DynamicRelationshipType.withName( "SUBCATEGORYOF" ),null );
                            if(Math.random()<0.1)
                                System.out.println(riga);                       }
                        else{
                            //è una pagina
                            if(Math.random()<0.1)
                                System.out.println(riga);
                            inserter.createRelationship(idelem, idcat, DynamicRelationshipType.withName( "BELONGSTO" ),null );

                        }

                    }
                }
            }
            else
                continue;



        }
        // Make sure to shut down the index provider
        indexProvider.shutdown();
        inserter.shutdown();
    }

}

class Lettore implements Iterable<String> {

    private String risorsa;
    private BufferedReader in;
    private boolean isURL;
    private boolean isFolder;
    private int riga;

    public static void main(String argc[]) throws IOException {
        // Lettore l=new Lettore("mio_gioco/edit.dat");
        // System.out.println(l);
        // Lettore d=l.creaDa("test.map");
        // System.out.println(d);

        Lettore f = new Lettore("mio_gioco/cells");
        System.out.println(f);
        System.out.println(f.isFolder);

        Lettore nf = f.creaDa("city.png");
        System.out.println(nf);
        System.out.println(nf.isFolder);

    }

    /**
     * Crea un lettore che punti al file, alla cartella o all'URL indicati
     *
     * @param indirizzo
     *            il percorso assoluto o relativo nel filesystem o l'URL
     * */
    public Lettore(String indirizzo) {
        // il lettore deve fare riferimento a un file o un URL,
        // e deve poter creare un lettore partendo da un indirizzo relativo
        // gestendo le diverse scritture dei file e semplificandone l'uso

        this.risorsa = indirizzo;

        if (risorsa.startsWith("http://")) {
            this.isURL = true;
            if (risorsa.endsWith("/"))
                isFolder = true;

        } else {
            this.isURL = false;
            risorsa = (new File(indirizzo)).getAbsolutePath();
            if (new File(risorsa).isDirectory()) {
                isFolder = true;
                return;
            }
        }
    }

    public Lettore(File cartella) throws IOException {
        this(cartella.getAbsolutePath());
    }

    /**
     * Restituisce un oggetto di tipo BufferedReader per la risorsa che
     * rappresenta La risorsa potrebbe non essere accessibile o essere una
     * cartella, quindi posso lanciare delle eccezioni
     * */
    public BufferedReader getReader() throws MalformedURLException, IOException {
        if (in != null)
            return in;
        if (this.isURL) {
            return new BufferedReader(new InputStreamReader(
                    (new URL(risorsa)).openStream()));
        } else {

            FileInputStream fstream = new FileInputStream(risorsa);
            DataInputStream dis = new DataInputStream(fstream);
            in = new BufferedReader(new InputStreamReader(dis));
            return in;
        }

    }

    /**
     * Apre un BufferedReader, se non era già aperto, e legge la prima stringa
     * dal file a ogni chiamata legge la successiva stringa o restituisce null
     * se arriva alla fine
     * */
    public String leggi() throws IOException {
        if (in == null) {
            if (this.isURL) {
                in = new BufferedReader(new InputStreamReader(
                        (new URL(risorsa)).openStream()));
            } else {

                FileInputStream fstream = new FileInputStream(risorsa);
                DataInputStream dis = new DataInputStream(fstream);
                in = new BufferedReader(new InputStreamReader(dis));
            }
        }
        riga++;
        return in.readLine();

    }

    public String toString() {
        if (!this.isURL && this.isFolder) {
            return risorsa + File.separatorChar;
        }
        return risorsa;
    }

    /**
     * crea un altro Lettore partendo da un percorso che può essere relativo a
     * quello attuale
     * */
    public Lettore creaDa(String indirizzo) {
        // vari casi possibili:

        // È un URL completo
        if (indirizzo.startsWith("http://"))
            return new Lettore(indirizzo);
        // È un percorso assoluto di file su filesystem tipo UNIX
        if (File.separatorChar == '/' && indirizzo.matches("/.+"))
            return new Lettore(indirizzo);
        // È un percorso assoluto di file su filesystem di tipo DOS (Windows)
        if (File.separatorChar == '\\' && indirizzo.matches("[a-zA-Z]:\\.+"))
            return new Lettore(indirizzo);

        // la parte importante:indirizzo relativo

        // il mio indirizzo è un URL o in un filesystem unix
        if (this.isURL() || risorsa.startsWith("/")) {
            String folder;
            if (isFolder)
                folder = risorsa;
            else
                folder = risorsa.substring(0, risorsa.lastIndexOf('/'));

            // converto le barre \ in /
            return new Lettore(folder + "/" + indirizzo.replace('\\', '/'));
        }

        // il mio indirizzo è un file in un filesystem windows
        if (risorsa.matches("[a-zA-Z]:\\.+")) {
            String folder;
            if (isFolder)
                folder = risorsa;
            else
                folder = risorsa.substring(0, risorsa.lastIndexOf('\\'));
            return new Lettore(folder + "\\" + indirizzo.replace('/', '\\'));
        }

        // se non sono ancora ritornato, mi trovo qui e c'è stato un errore
        // TODO come gestirlo?
        return null;

    }

    public boolean isURL() {
        return isURL;
    }

    public int getNumeroRiga() {
        return this.riga;
    }

    /**
     * restituisce il percorso relativo a quello corrente, se possibile, di un
     * percorso dato altrimenti quello assoluto
     *
     * @throws IOException
     *             se il file non esiste
     * */
    public String getPercorsoRelativo(String percorso) throws IOException {
        // mi basta controllare che il percorso assoluto della cartella mio file
        // contenga quello della cartella del percorso dato
        String percorsoAssoluto = this.creaDa(percorso).toString();

        String cartellaAssoluta = "";

        if (!this.isFolder && (this.isURL || File.separatorChar == '/'))
            cartellaAssoluta = risorsa.substring(0, risorsa.lastIndexOf('/'));
        if (!this.isFolder && (!this.isURL && File.separatorChar == '\\'))
            cartellaAssoluta = risorsa.substring(0, risorsa.lastIndexOf('\\'));

        // aggiungo +1 per lo \ o lo /, che devono essere eliminati
        if (this.risorsa.startsWith(cartellaAssoluta))
            return percorsoAssoluto.substring(cartellaAssoluta.length() + 1);
        else
            return percorsoAssoluto;
    }

    public void chiudi() throws IOException {
        in.close();
    }

    public boolean isCartella() {
        return isFolder;
    }

    public Iterator<String> iterator() {

        try {
            return new Iteratore(this);
        } catch (IOException e) {
            // eccezione: file non apribile oppure già iterato.
            // lo riapro, per gestire il secondo caso
            try {
                return new Iteratore(new Lettore(this.risorsa));
            } catch (IOException e1) {
                e1.printStackTrace();
                return null;
            }
        }
    }

    class Iteratore implements Iterator {
        String riga = "";
        Lettore l;

        public Iteratore(Lettore lettore) throws IOException {
            l = lettore;
            riga = l.leggi();
        }

        public boolean hasNext() {
            return (riga != null);
        }

        public String next() {
            if (riga == null)
                throw new NoSuchElementException(
                        "Fine del file: non posso andare avanti!");
            String temp = riga;
            try {
                riga = l.leggi();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            return temp;
        }

        /**
         * Metodo non supportato lancia sempre un'eccezione
         * */
        public void remove() {
            // operazione non supportata
            throw new UnsupportedOperationException(
                    "Errore nell'iteratore del Lettore: non posso rimuovere elementi! file:"
                            + l.toString());
        }

    }
}