18 Integration mit Datenbanken

Go unterstützt die Integration mit vielen verschiedenen Datenbanken, sowohl relationale als auch NoSQL-Datenbanken. Wir werden uns hier auf die Verwendung von SQLite als Beispiel konzentrieren, da es einfach einzurichten und zu verwenden ist.

18.0.1 Installation des SQLite-Treibers

Um SQLite in Go zu verwenden, müssen wir den entsprechenden Treiber installieren. Wir verwenden mattn/go-sqlite3:

go get github.com/mattn/go-sqlite3

18.1 Erstellen einer Datenbankverbindung

Zuerst erstellen wir eine Verbindung zur Datenbank. Hier ein einfaches Beispiel:

package main

import (
    "database/sql"
    "fmt"
    _ "github.com/mattn/go-sqlite3"
)

func main() {
    db, err := sql.Open("sqlite3", "./test.db")
    if err != nil {
        fmt.Println("Error opening database:", err)
        return
    }
    defer db.Close()

    fmt.Println("Database connection established")
}

In diesem Beispiel:

  1. Wir importieren das database/sql-Paket und den SQLite-Treiber.
  2. Wir öffnen eine Verbindung zur Datenbank test.db.
  3. Wir überprüfen, ob die Verbindung erfolgreich hergestellt wurde, und schließen die Verbindung am Ende des Programms.

18.2 Erstellen von Tabellen

Sobald wir eine Verbindung zur Datenbank haben, können wir eine Tabelle erstellen:

package main

import (
    "database/sql"
    "fmt"
    _ "github.com/mattn/go-sqlite3"
)

func main() {
    db, err := sql.Open("sqlite3", "./test.db")
    if err != nil {
        fmt.Println("Error opening database:", err)
        return
    }
    defer db.Close()

    createTableSQL := `CREATE TABLE IF NOT EXISTS users (
        "id" INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
        "name" TEXT
    );`

    _, err = db.Exec(createTableSQL)
    if err != nil {
        fmt.Println("Error creating table:", err)
        return
    }

    fmt.Println("Table created successfully")
}

In diesem Beispiel:

  1. Wir definieren eine SQL-Anweisung, um eine Tabelle namens users zu erstellen.
  2. Wir führen die SQL-Anweisung mit db.Exec aus und überprüfen, ob ein Fehler aufgetreten ist.

18.3 Einfügen von Daten

Nun fügen wir einige Daten in die Tabelle ein:

package main

import (
    "database/sql"
    "fmt"
    _ "github.com/mattn/go-sqlite3"
)

func main() {
    db, err := sql.Open("sqlite3", "./test.db")
    if err != nil {
        fmt.Println("Error opening database:", err)
        return
    }
    defer db.Close()

    insertUserSQL := `INSERT INTO users (name) VALUES (?)`
    statement, err := db.Prepare(insertUserSQL)
    if err != nil {
        fmt.Println("Error preparing statement:", err)
        return
    }
    defer statement.Close()

    _, err = statement.Exec("Alice")
    if err != nil {
        fmt.Println("Error inserting data:", err)
        return
    }

    fmt.Println("Data inserted successfully")
}

In diesem Beispiel:

  1. Wir definieren eine SQL-Anweisung zum Einfügen eines neuen Benutzers.
  2. Wir bereiten die SQL-Anweisung mit db.Prepare vor.
  3. Wir führen die vorbereitete Anweisung mit statement.Exec aus und fügen den Benutzer “Alice” ein.

18.4 Abrufen von Daten

Schließlich rufen wir die Daten aus der Tabelle ab und zeigen sie an:

package main

import (
    "database/sql"
    "fmt"
    _ "github.com/mattn/go-sqlite3"
)

func main() {
    db, err := sql.Open("sqlite3", "./test.db")
    if err != nil {
        fmt.Println("Error opening database:", err)
        return
    }
    defer db.Close()

    query := `SELECT id, name FROM users`
    rows, err := db.Query(query)
    if err != nil {
        fmt.Println("Error querying data:", err)
        return
    }
    defer rows.Close()

    for rows.Next() {
        var id int
        var name string
        err = rows.Scan(&id, &name)
        if err != nil {
            fmt.Println("Error scanning row:", err)
            return
        }
        fmt.Printf("ID: %d, Name: %s\n", id, name)
    }
}

In diesem Beispiel:

  1. Wir definieren eine SQL-Abfrage, um die id und name aus der Tabelle users auszuwählen.
  2. Wir führen die Abfrage mit db.Query aus und erhalten die Ergebnismenge rows.
  3. Wir durchlaufen die Ergebnismenge und scannen jede Zeile in Variablen id und name, die wir dann ausgeben.