Comment implémenter SQLite avec Golang

Avec le développement d'Internet, le traitement des données prend de plus en plus d'importance. Parmi eux, la base de données relationnelle est un élément nécessaire de nombreux projets, et SQLite est une base de données relationnelle légère largement utilisée dans diverses applications liées aux bases de données. Golang, en tant que langage de programmation doté d'une vitesse d'exécution efficace et d'un style de syntaxe concis, a également reçu de plus en plus d'attention. Cet article présente principalement comment utiliser Golang pour implémenter SQLite.

1. Introduction à SQLite

SQLite est une base de données relationnelle légère open source qui prend en charge plusieurs systèmes d'exploitation. Il est conçu pour être intégré, c'est-à-dire qu'il peut être intégré à d'autres applications en tant que moteur de stockage de données interne, ou qu'il peut fonctionner en tant que serveur de base de données autonome. Dans Golang, nous pouvons accéder à la base de données SQLite en utilisant go-sqlite3.

2. Installez go-sqlite3

Avant d'installer go-sqlite3, vous devez d'abord installer la base de données SQLite, qui peut être téléchargée sur le site officiel (https://www.sqlite.org/download.html). Les variables d'environnement doivent être définies pendant le processus d'installation pour faciliter l'accès à SQLite dans Golang.

Ensuite, installez go-sqlite3 via la commande go get :

go get github.com/mattn/go-sqlite3

3. Établissez une connexion à la base de données

Avant d'utiliser golang pour faire fonctionner SQLite, vous devez d'abord établir une connexion avec celui-ci. Voici un exemple simple d'établissement d'une connexion à une base de données SQLite :

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(err)
        return
    }
    defer db.Close()

    // 测试连接是否成功
    err = db.Ping()
    if err != nil {
        fmt.Println(err)
        return
    }

    fmt.Println("database connected")
}

Nous avons établi une connexion à la base de données SQLite nommée test.db dans le programme via la fonction sql.Open. Il convient de noter ici que la connexion créée à l'aide de cette fonction est une connexion légère, la connexion doit donc être fermée explicitement après le retour de la fonction.

Vous pouvez tester si la connexion est réussie via la fonction db.Ping. En cas de succès, "base de données connectée" sera imprimée.

4. Utiliser la base de données

Après avoir établi la connexion à la base de données, l'étape suivante consiste à effectuer diverses opérations sur la base de données. Vous trouverez ci-dessous quelques exemples d'opérations de base de données courantes.

1. Créer une table de données

Dans SQLite, vous pouvez utiliser des instructions SQL pour créer des tables de données. Voici un exemple simple de création d'une table de données :

_, err = db.Exec(`
    CREATE TABLE users (
        id INTEGER PRIMARY KEY AUTOINCREMENT,
        name TEXT,
        age INTEGER,
        gender INTEGER
    )
`)
if err != nil {
    fmt.Printf("create table failed: %v\n", err)
}

Dans le code, nous utilisons la fonction db.Exec pour exécuter l'instruction SQL qui crée la table de données. La valeur de retour de cette fonction est nulle après une exécution réussie, sinon un message d'erreur de type error est renvoyé.

2. Insérer des données

L'insertion de données est également une opération très courante. Voici un exemple d'insertion de données :

res, err := db.Exec("INSERT INTO users(name, age, gender) VALUES (?, ?, ?)", "张三", 18, 1)
if err != nil {
    fmt.Printf("insert data failed: %v\n", err)
}

lastInsertId, _ := res.LastInsertId() // 获取自增长ID
fmt.Printf("last insert id: %d\n", lastInsertId)

Dans le code, nous utilisons la fonction db.Exec pour exécuter une simple instruction SQL afin d'insérer une donnée dans la table de données. dans? Il s'agit d'un espace réservé, indiquant que les données réelles doivent être remplacées par l'espace réservé lors de l'exécution de l'instruction SQL. Si l'exécution réussit, la fonction db.Exec renverra une valeur de type Résultat, qui contient le dernier ID auto-croissant des données.

3. Interrogation de données

L'interrogation de données est également une opération très courante. Voici un exemple simple d'interrogation de données :

rows, err := db.Query("SELECT id, name, age, gender FROM users WHERE age > ?", 18)
if err != nil {
    fmt.Printf("query data failed: %v\n", err)
    return
}

defer rows.Close()

for rows.Next() {
    var id int
    var name string
    var age int
    var gender int

    err := rows.Scan(&id, &name, &age, &gender)
    if err != nil {
        fmt.Printf("get data failed: %v\n", err)
        return
    }

    fmt.Printf("%d\t%s\t%d\t%d\n", id, name, age, gender)
}

Dans le code, nous utilisons la fonction db.Query pour exécuter une simple instruction SQL de requête et obtenir. Toutes les données datant de plus de 18 ans et chaque élément de données est mappé à une variable via la fonction Scan.

4. Résumé

Cet article présente brièvement comment utiliser Golang pour faire fonctionner la base de données SQLite. Bien que les fonctions de SQLite ne soient pas aussi performantes que celles d'autres grandes bases de données relationnelles, elles sont également très adaptées à une utilisation dans certains petits projets. Combinées à la vitesse d'exécution efficace et au style de syntaxe concis de Golang, diverses opérations de base de données peuvent être rapidement mises en œuvre, rendant nos projets plus efficaces.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!