Golang Sqlite

SQLite est un moteur de données SQL simple, minimaliste, rapide et très fiable. C'est un choix très populaire et efficace pour les tests en raison de sa simplicité et de sa disponibilité.

Dans cet article, vous découvrirez comment travailler avec SQLite dans le langage de programmation Go. Ce tutoriel utilise un exemple très simple, ce qui le rend adapté aux débutants.

Exigences

Pour suivre ce tutoriel, vous aurez besoin de ce qui suit:

1. Dernière version du compilateur Go.
2. Un éditeur de texte de votre choix.
3. Connaissance de base de GO.

Une fois que vous avez rempli les exigences, nous pouvons continuer.

Configuration de l'environnement

La première étape consiste à créer un environnement de test pour créer une application Go. Commencez par créer un répertoire à l'aide de la commande:

MKDIR SQLITE-TEST

Ensuite, naviguez dans le répertoire et initialisez à l'aide de la commande:

CD SQLITE-TEST
GO MOD INIT SQLITE-TEST

Une fois que vos modules ont initialisé, créez un fichier principal Go:

toucher la main.aller

Ensuite, importez le package Go-Sqlite-3. Ce package nous permet de travailler avec des bases de données SQLite en utilisant Go.

Ajoutez la ligne suivante à votre principal.Fichier Go:

importer _ "github.com / Mattn / go-sqlite3 "

Exécutez la commande ci-dessous pour installer les packages.:

aller mod bien rangé

Alternativement, vous pouvez exécuter la commande ci-dessous pour installer manuellement le package Go-Sqlite3:

Allez chercher Github.com / Mattn / go-sqlite3

Créer un fichier de base de données

Étant donné que SQLite est une base de données basée sur des fichiers, nous devons créer un fichier de base de données pour stocker les données. Nous pouvons le faire en utilisant le système d'exploitation.Méthode Create ().

Un exemple est comme indiqué:

fichier, err: = os.Créer ("Base de données.db ")
Si err != nil
enregistrer.Fatal (euh)

déposer.Fermer()

Créer une fonction de table

Pour ajouter une table à la base de données, nous pouvons ouvrir le fichier pour la lecture, puis ajouter le tableau spécifié. Dans cet exemple, nous créerons une fonction qui prend des commandes SQL brutes pour ajouter un nouveau tableau.

Un exemple est comme indiqué:

Func CreateTable (DB * SQL.Db)
Users_Table: = 'Créer des utilisateurs de table (
ID INTEGER NON NULL PRIMATION CLIE AUTORNAGE,
Texte "FirstName",
Texte "LastName",
Texte "Dept",
"Salaire" int); '
requête, err: = db.Préparer (users_table)
Si err != nil
enregistrer.Fatal (euh)

mettre en doute.Exec ()
fmt.Println ("Tableau créé avec succès!")

Dans l'exemple ci-dessus, nous créons une fonction qui prend une requête SQL brute et s'exécute par rapport à la base de données spécifiée. Cela créera une table de base de données dans SQLite.

Insérer la fonction d'enregistrement

La partie suivante consiste à créer une fonction qui nous permet d'insérer des enregistrements dans le tableau. Un exemple de code est comme indiqué:

Func Addeurs (DB * SQL.Db, firstName String, LastName String, Dept String, Salaire int)
Enregistrements: = 'Insérer dans les valeurs des utilisateurs (FirstName, LastName, Dept, Salaire) (?, ?, ?, ?)) '
requête, err: = db.Préparer (enregistrements)
Si err != nil
enregistrer.Fatal (euh)

_, err = requête.Exec (FirstName, LastName, Dept, Salaire)
Si err != nil
enregistrer.Fatal (euh)

Fonction des enregistrements de récupération

La fonction finale que nous devons créer est celle qui récupère les enregistrements stockés dans la base de données, un exemple est comme indiqué:

func fetchrecords (db * sql.Db)
Enregistrer, err: = db.Query ("SELECT * FROM Users")
Si err != nil
enregistrer.Fatal (euh)

record de report.Fermer()
pour l'enregistrement.Suivant()
var id int
Var FirstName String
Var LastName String
String Var Dept
var salaire int
enregistrer.Scan (& id, & Firstname, & LastName, & Dept, & Salaire)
fmt.Printf ("utilisateur:% d% s% s% s% d", id, firstname, lastname, département, salaire)

La fonction ci-dessus utilise l'itérateur de curseur pour récupérer les lignes de la base de données.

Exécutez des requêtes sur la base de données

Une fois que nos fonctions ont été déclarées, nous devons les appeler pour ajouter les enregistrements dans la base de données. Nous allons commencer par ouvrir le fichier de base de données. Ensuite, nous appelons les méthodes CreateTable () et AddUsers ().

L'exemple de code est comme indiqué:

base de données, _: = SQL.Open ("Sqlite3", "Databsase.db ")
CreateTable (base de données)
Addeurs (base de données, "Ankita", "Maudie", "Game Developer", 140000)
Addeurs (base de données, "Emiliana", "Alfiya", "Bakend Developer", 120000)
AddUsers (base de données, "Emmet", "Brian", "DevOps Developer", 110000)
Addeurs (base de données, "Reidun", "Jorge", "Developer Dtabase", 140000)
Addeurs (base de données, "Tyrone", "Silvia", "Developer front-end", 109000)
reporter la base de données.Fermer()
// Recherche des enregistrements:
FetchRecords (base de données)

La section ci-dessus ouvre la base de données pour la lecture et insère les enregistrements à l'aide de la méthode AddUsers ().

Compiler et courir

Pour construire le programme, vous devrez installer le compilateur GCC sur votre système. Ceci est requis par le package Go-Sqlite3. Vérifiez la ressource ci-dessous pour apprendre à installer les dépendances sur votre système.

https: // github.com / Mattn / go-sqlite3

Vous pouvez maintenant créer le code comme:

aller construire principal.aller

Vous pouvez exécuter le programme comme:

./principal.exe

Le code doit renvoyer les enregistrements stockés dans la base de données. Un exemple de sortie est comme indiqué:

Conclusion

Ce guide explique comment utiliser la base de données SQLite dans le Golang à l'aide du package Go-Sqlite3. Vérifiez les documents pour en savoir plus.