0

SQlite Java

Merhaba Arkadaşlar bu yazımda yada yazı dizisinde Java ile Sqlite veritabanı bağlantısı kuracağız ve temel veritabanı işlemlerini nasıl yapacağız bunları inceleyeceğiz ve örnekler vererek konuyu açıklığa kavuşturacağız. SQlite hem küçük , hem kolay kurulumlu, hem hızlı , hem performanslı ve mobil uygulamalarda tavsiye edilen bir veritabanı. Sadece java projelerinde değil birçok programlama dili ile kullanabileceğiniz pratik bir veritabanı .

Şimdi bu konuyu incelerken neler öğreneceğiz bir bakalım;

  • SQlite veritabanına bağlantı kurmak
  • Yeni bir veritabanı oluşturma
  • Jdbc ile yeni bir tablo oluşturma
  • Oluşturduğumuz tabloya veri girme
  • Tablomuzdan sorgu yapma
  • PreparedStatement kullanarak update yapmak
  • Tablodan veri silme
  • Transaction işlemleri

SQlite veritabanı ile bağlantı kurmak

Bildiğiniz üzere ( yada şimdi öğrenebilirsiniz ) herhangi bir veritabanına bağlanabilmek için ilk önce o veritabanına ait driver’i yüklemek gerekiyor.  SQlite veritabanına bağlanabilmek için  SQLiteJDBC  driver’i indirmek ile işe başlayacağız.

SQlite JDBC driver’i indirmek için  bitbucket sitesine gidip  en son jdbc driver versiyonu indiriyoruz.  Buradan indireceğiniz .jar dosyası bütün sistemler için uygundur kullanılabilir.

SQlite JDBC Driver’i projemize ekleme 

Kullandığınız ide’ye göre ekleme yöntemi farklılık gösterebilir. IntelliJ idesi için söylecek olursak  File – Project Structure – Libraries kısmından indirdiğimiz .jar uzantılı api’yi projemize ekleyelim.

diğer ide’lere nasıl eklendiği çalıştığınız ide ile alakalı sitelerde mevcuttur. Buradan devam edelim.

SQLite connection string

SQLite database driver ile veritabanına bağlanmak için connection string’e ihtiyacımız olacak

	
jdbc:sqlite:sqlite_database_file_path

Bağlantı kuracağımız veritabanının yolunu absolute(kesin) yada relative(bağımlı) olarak belirtilebilir.

jdbc:sqlite:sample.db

yada

jdbc:sqlite:C:/sqlite/db/sample.db

SQLite veritabanına JDBC ile bağlantı kurmak

package net.sqlitetutorial;
 
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
 


public class SQLiteJDBCDriverConnection {
     /**
     * Connect to a sample database
     */
    public static void connect() {
        Connection conn = null;
        try {
            // db parameters
            String url = "jdbc:sqlite:C:/sqlite/db/sample.db";
            // create a connection to the database
            conn = DriverManager.getConnection(url);
            
            System.out.println("Connection to SQLite has been established.");
            
        } catch (SQLException e) {
            System.out.println(e.getMessage());
        } finally {
            try {
                if (conn != null) {
                    conn.close();
                }
            } catch (SQLException ex) {
                System.out.println(ex.getMessage());
            }
        }
    }
    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        connect();
    }
}
Connection to SQLite has been established.

şeklinde ekran çıktısı alacaksınız.

SQlite ile yeni bir veritabanı oluşturmak

Bu bölümde yeni bir SQLite veritabanını jdbc ile nasıl oluşturacağız buna bakalım.

package net.sqlitetutorial;
 
import java.sql.Connection;
import java.sql.DatabaseMetaData;
import java.sql.DriverManager;
import java.sql.SQLException;
 

public class Main {
 
    /**
     * Connect to a sample database
     *
     * @param fileName the database file name
     */
    public static void createNewDatabase(String fileName) {
 
        String url = "jdbc:sqlite:C:/sqlite/db/" + fileName;
 
        try (Connection conn = DriverManager.getConnection(url)) {
            if (conn != null) {
                DatabaseMetaData meta = conn.getMetaData();
                System.out.println("The driver name is " + meta.getDriverName());
                System.out.println("A new database has been created.");
            }
 
        } catch (SQLException e) {
            System.out.println(e.getMessage());
        }
    }
 
    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        createNewDatabase("test.db");
    }
}
run:
The driver name is SQLiteJDBC
A new database has been created.
BUILD SUCCESSFUL (total time: 0 seconds)

Yeni bir Tablo oluşturma

Oluşturduğumuz veritabanı içinde yeni bir tablo oluşturmak için şu adımları izleyelim

  1. İlk olarak  “CREATE TABLE”  sql cümlesi oluşturacağız
  2. Veritabanımıza bağlantı kuracağız
  3. Connection nesnesi üzerinden “Statement” nesnesi oluşturacağız
  4. Statement objesinin executeUpdate() metodunu kullanarak CREATE TABLE cümlemizi çalıştıracağız.
package net.sqlitetutorial;
 
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;
 

public class Main {
 
    /**
     * Create a new table in the test database
     *
     */
    public static void createNewTable() {
        // SQLite connection string
        String url = "jdbc:sqlite:C://sqlite/db/tests.db";
        
        // SQL statement for creating a new table
        String sql = "CREATE TABLE IF NOT EXISTS warehouses (\n"
                + "	id integer PRIMARY KEY,\n"
                + "	name text NOT NULL,\n"
                + "	capacity real\n"
                + ");";
        
        try (Connection conn = DriverManager.getConnection(url);
                Statement stmt = conn.createStatement()) {
            // create a new table
            stmt.execute(sql);
        } catch (SQLException e) {
            System.out.println(e.getMessage());
        }
    }
 
    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        createNewTable();
    }
 
}

Select ile Verileri Çekme

  1. Connection nesnesi ile SQLite veritabanına bağlanacağız
  2. Connection nesnesi üzerinden bir Statement nesnesi oluşturacağız
  3. Statement nesnesinin executeQuery() metodu ile verileri çekip bir ResultSet nesnesine atayacağız.
  4. ResultSet objesine alınan dataları bir döngü içinde  next() metodu ile alacağız.
  5. Bu dataları alırken ResultSet nesnesinin getInt(),getString(),getDouble() metodları ile  bilgileri model imize aktaracağız.
package net.sqlitetutorial;
 
import java.sql.DriverManager;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
 

public class SelectApp {
 
    /**
     * Connect to the test.db database
     * @return the Connection object
     */
    private Connection connect() {
        // SQLite connection string
        String url = "jdbc:sqlite:C://sqlite/db/test.db";
        Connection conn = null;
        try {
            conn = DriverManager.getConnection(url);
        } catch (SQLException e) {
            System.out.println(e.getMessage());
        }
        return conn;
    }
 
    
    /**
     * select all rows in the warehouses table
     */
    public void selectAll(){
        String sql = "SELECT id, name, capacity FROM warehouses";
        
        try (Connection conn = this.connect();
             Statement stmt  = conn.createStatement();
             ResultSet rs    = stmt.executeQuery(sql)){
            
            // loop through the result set
            while (rs.next()) {
                System.out.println(rs.getInt("id") +  "\t" + 
                                   rs.getString("name") + "\t" +
                                   rs.getDouble("capacity"));
            }
        } catch (SQLException e) {
            System.out.println(e.getMessage());
        }
    }
    
   
    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        SelectApp app = new SelectApp();
        app.selectAll();
    }
 
}

Parametre Kullanarak Sorgu oluşturma

Eğer parametre kullanarak sorgu yapacaksanız o zaman “PreparedStatement” kullanılır.  Örneğimizde capacity değeri belli değerden yüksek olanları getiren bir sorgu hazırlayalım.

/**
     * Get the warehouse whose capacity greater than a specified capacity
     * @param capacity 
     */
    public void getCapacityGreaterThan(double capacity){
               String sql = "SELECT id, name, capacity "
                          + "FROM warehouses WHERE capacity > ?";
        
        try (Connection conn = this.connect();
             PreparedStatement pstmt  = conn.prepareStatement(sql)){
            
            // set the value
            pstmt.setDouble(1,capacity);
            //
            ResultSet rs  = pstmt.executeQuery();
            
            // loop through the result set
            while (rs.next()) {
                System.out.println(rs.getInt("id") +  "\t" + 
                                   rs.getString("name") + "\t" +
                                   rs.getDouble("capacity"));
            }
        } catch (SQLException e) {
            System.out.println(e.getMessage());
        }
    }
SelectApp app = new SelectApp();
app.getCapacityGreaterThan(3600);

burada sorgu içindeki “?” işareti buraya bir parametre gelecek demektir.

Tabloya Veri Ekleme

Bu bölümde de “INSERT” komutunu kullanarak tablomuza nasıl veri ekleriz buna bakalım.  şimdi yapacaklarımızı adım adım yazalım..
  1. İlk önce SQlite veritabanına bağlanalım.
  2. Yeni bir INSERT sql cümlesi oluşturalım. Eğer parametre kullanacaksanız buradaki her parametre yerine ( ? )  kullanmalısınız.
  3. Connection nesnesi üzerinden PreparedStatement nesnesi oluşturuyoruz.
  4. PreparedStatement nesnesinin setInt() , setString() gibi metodlarını kullanarak parametreleri set edelim.
  5. son olarak da PreparedStatement nesnesinin executeUpdate() metodu ile sorgumuzu çalıştıralım.
package net.sqlitetutorial;
 
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;
 

public class InsertApp {
 
    /**
     * Connect to the test.db database
     *
     * @return the Connection object
     */
    private Connection connect() {
        // SQLite connection string
        String url = "jdbc:sqlite:C://sqlite/db/test.db";
        Connection conn = null;
        try {
            conn = DriverManager.getConnection(url);
        } catch (SQLException e) {
            System.out.println(e.getMessage());
        }
        return conn;
    }
 
    /**
     * Insert a new row into the warehouses table
     *
     * @param name
     * @param capacity
     */
    public void insert(String name, double capacity) {
        String sql = "INSERT INTO warehouses(name,capacity) VALUES(?,?)";
 
        try (Connection conn = this.connect();
                PreparedStatement pstmt = conn.prepareStatement(sql)) {
            pstmt.setString(1, name);
            pstmt.setDouble(2, capacity);
            pstmt.executeUpdate();
        } catch (SQLException e) {
            System.out.println(e.getMessage());
        }
    }
 
    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
 
        InsertApp app = new InsertApp();
        // insert three new rows
        app.insert("Raw Materials", 3000);
        app.insert("Semifinished Goods", 4000);
        app.insert("Finished Goods", 5000);
    }
 
}

Select metodu kullanarak verileri görüntüleyebilirsiniz.

Update ile verileri güncelleme

Bu bölümde de verilerimizi nasıl güncelleriz buna bakacağız öncelikle senaryomuzu yine yazalım.

  1.  ilk olarak SQLite veritabanımıza bağlantı kuracağız
  2. Yeni bir UPDATE sql sorgusu oluşturacağız.  Update sorgusu parametre alacağından ( ?) soru işaretini set edeceğimiz veriler için kullanacağız
  3. Connection nesnesi üzerinden yeni bir PreparedStatement nesnesi oluşturacağız.
  4. Oluşturduğumuz PreparedStatement nesnesine parametre değerlerini set etmek için setString()  , setInt() gibi metodları kullanacağız.
  5. Son aşamada PreparedStatement nesnesinin executeUpdate() metodu ile işlemimizi tamamlayacağız.
package net.sqlitetutorial;
 
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;
 

public class UpdateApp {
 
    /**
     * Connect to the test.db database
     *
     * @return the Connection object
     */
    private Connection connect() {
        // SQLite connection string
        String url = "jdbc:sqlite:C://sqlite/db/test.db";
        Connection conn = null;
        try {
            conn = DriverManager.getConnection(url);
        } catch (SQLException e) {
            System.out.println(e.getMessage());
        }
        return conn;
    }
 
    /**
     * Update data of a warehouse specified by the id
     *
     * @param id
     * @param name name of the warehouse
     * @param capacity capacity of the warehouse
     */
    public void update(int id, String name, double capacity) {
        String sql = "UPDATE warehouses SET name = ? , "
                + "capacity = ? "
                + "WHERE id = ?";
 
        try (Connection conn = this.connect();
                PreparedStatement pstmt = conn.prepareStatement(sql)) {
 
            // set the corresponding param
            pstmt.setString(1, name);
            pstmt.setDouble(2, capacity);
            pstmt.setInt(3, id);
            // update 
            pstmt.executeUpdate();
        } catch (SQLException e) {
            System.out.println(e.getMessage());
        }
    }
 
    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        
        UpdateApp app = new UpdateApp();
        // update the warehouse with id 3
        app.update(3, "Finished Products", 5500);
    }
 
}

Burada aklınıza takılabilecek bir soruya cevap vermek için ara verip bir konuya açıklık getirmeye çalışacağım. Yukarıdaki örneklerde  execute(), executeQuery() , executeUpdate() gibi bir kaç farklı metod kullandım. Bu metodlar hakkında bilgi vermek adına bir parantez açalım.

execute() : execute metodu sonucunda boolean geri dönüşü olan bir metotdur. Yani sql sorgusunu çalıştırır ve sonucunda size true/false gibi bir sonuç döndürür. Bu dönütün işinize yaramayacağı durumlarda bunu tercih etmemelisiniz.

executQuery() : Bu metod’da sql sorgusu çalıştırmak için kullanılır. Ancak bu metod sonucunda bir ResultSet nesnesi döner. Dolayısıyla select kullandığımız durumlarda bu metodu kullanmak mantıklıdır.

executeUpdate(): Bu metod ile de sql sorgusu çalıştrılır. Ancak bu metodu INSERT/UPDATE/DELETE sorgularında kullanmak mantıklıdır. Sonuçta size int türünde bir değer yollar. Bu şunu ifade eder ki ; diyelim 10 kayıt silindi size 10 değerini yollar. Yani sizin sorgunuz kaçtane kaydı etkiledi ise onları size döner.

şimdi devam edelim….

Delete ile istenen veriyi Silme

Evet bu bölümde de Tablodan nasıl veri silinir buna bakalım.  Senaryomuzu yazalım

  1.  İlk olarak SQlite Veritabanı bağlantımızı  yapalım
  2. Yeni bir DELETE sorgusu yazalım. Parametre için yine ( ? ) soru işareti kullanacağız.
  3. Connection nesnesi üzerinden yeni bir PreparedStatement nesnesi oluşturuyoruz
  4. Parametreleri set ettikten sonra , delete sorgumuzu executeUpdate() ile çalıştıracağız.
package net.sqlitetutorial;
 
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;
 

public class DeleteApp {
 
    /**
     * Connect to the test.db database
     *
     * @return the Connection object
     */
    private Connection connect() {
        // SQLite connection string
        String url = "jdbc:sqlite:C://sqlite/db/test.db";
        Connection conn = null;
        try {
            conn = DriverManager.getConnection(url);
        } catch (SQLException e) {
            System.out.println(e.getMessage());
        }
        return conn;
    }
 
    /**
     * Delete a warehouse specified by the id
     *
     * @param id
     */
    public void delete(int id) {
        String sql = "DELETE FROM warehouses WHERE id = ?";
 
        try (Connection conn = this.connect();
                PreparedStatement pstmt = conn.prepareStatement(sql)) {
 
            // set the corresponding param
            pstmt.setInt(1, id);
            // execute the delete statement
            pstmt.executeUpdate();
 
        } catch (SQLException e) {
            System.out.println(e.getMessage());
        }
    }
 
    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        DeleteApp app = new DeleteApp();
        // delete the row with id 3
        app.delete(3);
    }
 
}

id’si 3 olan kaydı silecek.

Transaction İşlemleri

Şimdi bu ne demek diye soracağınız bir başlık yazmış olabilirim ama açıklık getirelim.  Evet konuya başlamadan ilk önce 2 adet tablo oluşturacağız.

CREATE TABLE IF NOT EXISTS materials (
 id integer PRIMARY KEY,
 description text NOT NULL
);
 
CREATE TABLE IF NOT EXISTS inventory (
 warehouse_id integer,
 material_id integer,
 qty real,
 PRIMARY KEY (warehouse_id, material_id),
 FOREIGN KEY (warehouse_id) REFERENCES warehouses (id),
 FOREIGN KEY (material_id) REFERENCES materials (id)
);

Nedir bu Transaction ?

Transaction birçok sorguyu bir iş içinde çalıştırmayı ifade eder. Yapılan bu iş dizisininde işlemlerden birisi başarısız olursa yapılan bütün işlemler rollback olur yani geri alınır.  Bu konuya verilen meşhur örnek üzerinden bakarsak, ATM de para yatırma işlemi yada para çekme işlemi yapıyorsunuz işlem belli bir yerde yarıda kaldı  ne olacak ? bütün yapılan önceki işlemlerin hepsi geri alınmalı yoksa hiç iyi olmaz.

Şimdiye kadarki yaptığımız işlemler “Auto Commit ” idi yani yapıldığı anda veritabanında işlem kalıcı olarak işleniyordu.  Transaction kullanabilmek için “Auto Commit ” özelliğini kapatmak gerekiyor.  Auto Commit özelliğini Connection nesnesi üzerinden açıp kapatabiliriz.

 conn.setAutoCommit(false);

hal böyle olunca siz işlemleri yaptıktan sonra kendiniz “commit ” etmeniz gerekiyor.

conn.commit();

Eğer bu işlemler yapılırken bir sorun oluşursa işlemleri geri alabilmek için rollback() kullanabilirsiniz.

conn.rollback();
package net.sqlitetutorial;
 
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
 
/**
 *
 * @author sqlitetutorial.net
 */
public class TransactionApp {
 
    /**
     * Connect to the test.db database
     *
     * @return the Connection object
     */
    private Connection connect() {
        // SQLite connection string
        String url = "jdbc:sqlite:C://sqlite/db/test.db";
        Connection conn = null;
        try {
            conn = DriverManager.getConnection(url);
        } catch (SQLException e) {
            System.out.println(e.getMessage());
        }
        return conn;
    }
 
    /**
     * Create a new material and add initial quantity to the warehouse
     *
     * @param material
     * @param warehouseId
     * @param qty
     */
    public void addInventory(String material, int warehouseId, double qty) {
        // SQL for creating a new material
        String sqlMaterial = "INSERT INTO materials(description) VALUES(?)";
        
        // SQL for posting inventory
        String sqlInventory = "INSERT INTO inventory(warehouse_id,material_id,qty)"
                + "VALUES(?,?,?)";
 
        ResultSet rs = null;
        Connection conn = null;
        PreparedStatement pstmt1 = null, pstmt2 = null;
        
        try {
            // connect to the database
            conn = this.connect();
            if(conn == null)
                return;
            
            // set auto-commit mode to false
            conn.setAutoCommit(false);
            
            // 1. insert a new material
            pstmt1 = conn.prepareStatement(sqlMaterial,
                    Statement.RETURN_GENERATED_KEYS);
 
            pstmt1.setString(1, material);
            int rowAffected = pstmt1.executeUpdate();
 
            // get the material id
            rs = pstmt1.getGeneratedKeys(); // En son eklenen kaydın id sini alıyoruz
            int materialId = 0;
            if (rs.next()) {
                materialId = rs.getInt(1);
            }
 
            if (rowAffected != 1) {
                conn.rollback();
            }
            // 2. insert the inventory
            pstmt2 = conn.prepareStatement(sqlInventory);
            pstmt2.setInt(1, warehouseId);
            pstmt2.setInt(2, materialId);
            pstmt2.setDouble(3, qty);
            // 
            pstmt2.executeUpdate();
            // commit work
            conn.commit();
 
        } catch (SQLException e1) {
            try {
                if (conn != null) {
                    conn.rollback();
                }
            } catch (SQLException e2) {
                System.out.println(e2.getMessage());
            }
            System.out.println(e1.getMessage());
        } finally {
            try {
                if (rs != null) {
                    rs.close();
                }
                if (pstmt1 != null) {
                    pstmt1.close();
                }
                if (pstmt2 != null) {
                    pstmt2.close();
                }
                if (conn != null) {
                    conn.close();
                }
            } catch (SQLException e3) {
                System.out.println(e3.getMessage());
            }
        }
    }
 
    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        TransactionApp app = new TransactionApp();
        app.addInventory("HP Laptop", 3, 100);
    }
 
}

Kaynak: http://www.sqlitetutorial.net/sqlite-java/

admin

Bir cevap yazın

E-posta hesabınız yayımlanmayacak. Gerekli alanlar * ile işaretlenmişlerdir