6. diel - Databázový wrapper v Jave - Tvorba triedy Query

V minulom dieli seriálu tutoriálov o databázach v Jave sme započali tvorbu databázového Wrapper, ktorý nám zjednoduší prácu s databázou. Dnešný diel bude hlavne o programovaní. Ešte než začneme programovať samotnú triedu Database, tak si pripravíme triedu Query, ktorá bude znázorňovať samotný SQL dotaz.

Trieda Query

V balíčku DB si vytvoríme novú triedu Query. V nej budeme pomocou metód postupne zostavovať SQL dotaz. Po tomto kroku bude náš projekt vyzerať asi takto:

V triede si vytvoríme metódu delete a metódu where, ktorú budeme používať veľmi často.

public class Query {
    private StringBuilder query;

    /**
     *
     * @param table
     * @return
     */
    public Query delete(String table){
        query = new StringBuilder();
        query.append("DELETE FROM ");
        query.append(table);
        return this;
    }

    /**
     * Přidá podmínku do sql dotazu
     * @param requirement
     * @return
     */
    public Query where(String requirement){
    query.append(" WHERE ");
        query.append(requirement);
        return this;
    }

   /**
     *
     * @param table
     * @return
     */
    public Query from(String table){
        query.append(" FROM ");
        query.append(table);
        return this;
    }
}

Vďaka triede StringBuilder môžeme ľahšie poskladať naše SQL dotazy a uložiť ich do inštančný premennej query. Metóda append jednoducho pridá časť textu, znak, alebo premenou do poľa. Premenná môže byť akéhokoľvek dátového typu (Object, String, char, boolean, double, int, float, atď.).

Inštanciu triedy StringBuilder môžeme premeniť na textový reťazec pomocou metódy toString.

Dôležitá pre nás je metóda where, pretože tu využijeme najčastejšie.

Metódy update a set

Podobne pridáme aj metódy update a set:

public class Query {
    //proměnné třídy
    //metody třídy
    /**
     *
     * @param table
     * @return
     */
    public Query update(String table){
        query = new StringBuilder();
        query.append("UPDATE ");
        query.append(table);
        query.append(" SET ");
        return this;
    }

    /**
     * Doplní sloupce
     * @param Columns
     */
    public Query set(String[] columns){
        int count = columns.length;
        if(count == 0)
            throw new IllegalArgumentException("Neplatný počet parametrů");

        for(String column : columns){
           query.append(column);
           query.append(" = ");
           query.append("?");
           query.append(",");
        }
        query.deleteCharAt(query.lastIndexOf(","));
        return this;
    }
}

Tak a teraz si povieme prečo máme na konci každej metódy return this; Je to jednoduché. Každá metóda v triede Query je dátového typu Query. To znamená, že vracia inštancií danej triedy. Má to tú výhodu, že môžeme zefektívniť kód. A miesto takého kódu:

query.update(table);
query.set(columns);
query.where(requirement);

Môžeme efektívne napísať toto:

query.update(table).set(columns).where(requirement);

Takému zápise sa hovorí plynulé rozhranie (Fluent Interface). Pomáha nám to vytvárať aplikačné rozhranie, ktoré je veľmi čitateľné a pochopiteľné. Plynulé rozhranie vytvoril Martin Fowler a je to technika objektovej orientovaného programovania, kde ako sme si už vyššie ukázali, řetězíme po sebe idúce volanie metód toho istého objektu.

Ďalej stojí za povšimnutie, že v metóde set testujeme, či ak neposielame prázdny parameter. V prípade, že pošleme neplatný parameter, tak sa vyvolá výnimka IllegalArgumen­tException. Nakoniec len spomeniem, že metóda deleteCharAt nám odoberie posledný nežiaduce čiarku, ale vnútornú logiku metód si aj s príklady preberieme v inej časti tohto tutoriálu.

Metódy insert a values

Pridajme metódy insert a values:

public class Query {
    //proměnné třídy
    //metody třídy
    /**
     *
     * @param table
     * @return
     */
    public Query insert(String table){
        query = new StringBuilder();
        query.append("INSERT INTO ");
        query.append(table);
        return this;
    }

    /**
     *
     * @param params
     * @return
     */
    public Query values(Object[] params){
        query.append(" VALUES(");

        int count = params.length;

        if(count == 0)
            throw new IllegalArgumentException("Neplatný počet parametrů");

        for (int i = 0; i<count; i++) {
            query.append("?,");
        }
        //odstaníme poslední čárku
        query.deleteCharAt(query.lastIndexOf(","));
        query.append(");");
        return this;
    }
}

V metóde insert nie je nič nové. Metóda values berie ako parameter poľa objektov a za každý prvok dosadí do SQL dotazu "?". Nakoniec sa odstráni posledná čiarka a vráti inštancie triedy Query. Pokiaľ bude počet parametrov rovný nule, vyvolá sa výnimka IllegalArgumen­tException.

Metóda select a pomocné metódy

public class Query {
    //proměnné třídy
    //metody třídy
    /**
     *
     * @param columns
     * @return
     */
    public Query select(Object[] columns){
        query = new StringBuilder();
        query.append("SELECT ");
        if(columns != null){
            for(Object column : columns){
                query.append(column);
                query.append(",");
            }
            //odstaníme poslední otazník
            query.deleteCharAt(query.lastIndexOf(","));
        }
        else
            query.append("*");

        return this;
    }
}

Metóda select berie ako parameter pole objektov, ktoré reprezentujú jednotlivé stĺpce. Ak dáme metóde select ako parameter hodnotu null, dosadí do SQL dotazu znak *, ktorý vracia všetky stĺpce z databázovej tabuľky.

Metóda getQuery

public class Query {
    //proměnné třídy
    //metody třídy
     /**
     * Vrátí sestavený sql dotaz
     * @return query
     */
    public String getQuery(){
        return query.toString();
    }
}

Nakoniec budeme potrebovať výsledný SQL dotaz nejako získať. K tomuto účelu nám poslúžia metóda getQuery, ktorá nám vracia otázku ako textový reťazec za pomocou metódy toString.

V ďalšom diele si triedu Query otestujeme a vytvoríme si triedu Database.