Go语言如何操作Sqlite数据库？

## 简介

Go语言做一些小工具时，一般都想要项目体积越小越好，所以如果此时我们需要使用数据库，Sqlite是很好的选择。

在Go语言中，访问SQLite数据库通常使用 `github.com/mattn/go-sqlite3` 库。下面是从下载依赖到代码实践的详细步骤：

<!-- more -->

## 安装依赖
首先，确保你已经安装了Go，并且设置好了GOPATH。然后，你需要安装SQLite驱动程序：

```sh
复制代码
go get -u github.com/mattn/go-sqlite3
```

## 编写代码

下面是一个完整的示例代码，演示了如何在 Go 中使用 SQLite 数据库进行基本的 CRUD 操作。

```golang
// main.go

package main

import (
	"database/sql"
	"fmt"
	"log"

	_ "github.com/mattn/go-sqlite3"
)

func main() {
	// 打开数据库连接，如果数据库文件不存在则会创建一个新的数据库文件
	db, err := sql.Open("sqlite3", "./test.db")
	if err != nil {
		log.Fatal(err)
	}
	defer db.Close()

	// 创建一个表
	sqlStmt := `
	CREATE TABLE IF NOT EXISTS users (
		id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
		name TEXT,
		age INTEGER
	);
	`
	_, err = db.Exec(sqlStmt)
	if err != nil {
		log.Fatalf("%q: %s\n", err, sqlStmt)
		return
	}

	// 插入数据
	tx, err := db.Begin()
	if err != nil {
		log.Fatal(err)
	}
	stmt, err := tx.Prepare("INSERT INTO users(name, age) VALUES(?, ?)")
	if err != nil {
		log.Fatal(err)
	}
	defer stmt.Close()
	_, err = stmt.Exec("Alice", 30)
	if err != nil {
		log.Fatal(err)
	}
	_, err = stmt.Exec("Bob", 25)
	if err != nil {
		log.Fatal(err)
	}
	tx.Commit()

	// 查询数据
	rows, err := db.Query("SELECT id, name, age FROM users")
	if err != nil {
		log.Fatal(err)
	}
	defer rows.Close()
	for rows.Next() {
		var id int
		var name string
		var age int
		err = rows.Scan(&id, &name, &age)
		if err != nil {
			log.Fatal(err)
		}
		fmt.Printf("%d: %s, %d\n", id, name, age)
	}
	err = rows.Err()
	if err != nil {
		log.Fatal(err)
	}

	// 更新数据
	stmt, err = db.Prepare("UPDATE users SET age = ? WHERE name = ?")
	if err != nil {
		log.Fatal(err)
	}
	defer stmt.Close()
	_, err = stmt.Exec(35, "Alice")
	if err != nil {
		log.Fatal(err)
	}

	// 删除数据
	stmt, err = db.Prepare("DELETE FROM users WHERE name = ?")
	if err != nil {
		log.Fatal(err)
	}
	defer stmt.Close()
	_, err = stmt.Exec("Bob")
	if err != nil {
		log.Fatal(err)
	}

	// 再次查询数据
	rows, err = db.Query("SELECT id, name, age FROM users")
	if err != nil {
		log.Fatal(err)
	}
	defer rows.Close()
	for rows.Next() {
		var id int
		var name string
		var age int
		err = rows.Scan(&id, &name, &age)
		if err != nil {
			log.Fatal(err)
		}
		fmt.Printf("%d: %s, %d\n", id, name, age)
	}
	err = rows.Err()
	if err != nil {
		log.Fatal(err)
	}
}
```
### 代码说明
导入包：

1. 打开数据库：`sql.Open("sqlite3", "./test.db")`：打开名为 `test.db` 的 `SQLite` 数据库文件。如果文件不存在，将创建一个新的数据库文件。
2. 创建表：使用 `SQL` 语句 `CREATE TABLE IF NOT EXISTS users ...` 创建一个名为 `users` 的表，包含三个字段：`id`，`name` 和 `age`。
3. 插入数据：开启一个事务，并准备插入语句 `INSERT INTO users(name, age) VALUES(?, ?)`。使用stmt.Exec插入两条记录。
4. 查询数据：使用 `db.Query` 查询 `users` 表中的所有记录，并遍历结果集打印每条记录。
5. 更新数据：准备更新语句 `UPDATE users SET age = ? WHERE name = ?`，并更新 `Alice` 的年龄。
6. 删除数据：准备删除语句 `DELETE FROM users WHERE name = ?` ，并删除 `Bob` 的记录。
7. 再次查询数据：再次查询并打印 `users` 表中的所有记录，以验证更新和删除操作是否生效。

## 使用GORM简化开发工作

在Go语言中，有几个流行的 ORM 框架可以简化与 SQLite（以及其他关系型数据库）的交互。这些框架提供了一些高级特性，使得数据库操作更加简洁和直观。以下是其中最流行的一个：

- GORM：这是一个非常流行的ORM框架，支持多种数据库，包括`SQLite`、`MySQL`、`PostgreSQL`等。

### 安装

首先，安装 `GORM` 及其 `SQLite` 驱动：

```sh
go get -u gorm.io/gorm
go get -u gorm.io/driver/sqlite
```

### 代码
然后，我们可以用 `GORM` 重写前面的例子。

```go
// main.go

package main

import (
	"fmt"
	"gorm.io/driver/sqlite"
	"gorm.io/gorm"
)

// User 定义用户模型
type User struct {
	ID   uint   `gorm:"primaryKey"`
	Name string `gorm:"unique;not null"`
	Age  int
}

func main() {
	// 连接SQLite数据库
	db, err := gorm.Open(sqlite.Open("test.db"), &gorm.Config{})
	if err != nil {
		panic("failed to connect database")
	}

	// 自动迁移模式
	db.AutoMigrate(&User{})

	// 插入数据
	db.Create(&User{Name: "Alice", Age: 30})
	db.Create(&User{Name: "Bob", Age: 25})

	// 查询数据
	var users []User
	db.Find(&users)
	fmt.Println("Initial data:")
	for _, user := range users {
		fmt.Printf("%d: %s, %d\n", user.ID, user.Name, user.Age)
	}

	// 更新数据
	db.Model(&User{}).Where("name = ?", "Alice").Update("Age", 35)

	// 删除数据
	db.Where("name = ?", "Bob").Delete(&User{})

	// 再次查询数据
	db.Find(&users)
	fmt.Println("Updated data:")
	for _, user := range users {
		fmt.Printf("%d: %s, %d\n", user.ID, user.Name, user.Age)
	}
}
```
### 代码说明

定义一个 User 结构体表示用户模型，并使用 `GORM` 标签定义字段属性。

1. 连接数据库：使用 `gorm.Open` 连接 `SQLite` 数据库，并处理连接错误。
2. 自动迁移：使用 `db.AutoMigrate(&User{})` 自动迁移模式，确保数据库结构与模型匹配。
3. 插入数据：使用 `db.Create` 插入新的用户数据。
4. 查询数据：使用 `db.Find` 查询所有用户数据，并打印结果。
5. 更新数据：使用 `db.Model(&User{}).Where("name = ?", "Alice").Update("Age", 35)` 更新 `Alice` 的年龄。
6. 删除数据：使用 `db.Where("name = ?", "Bob").Delete(&User{})` 删除 `Bob` 的记录。
7. 再次查询数据：再次查询所有用户数据，并打印更新后的结果。

## 总结

本文首先展示了如何在 `Go` 中使用 `SQLite` 数据库进行基本的 `CRUD` 操作。尽管使用文件存储数据在某些简单场景中是可行的，但对于生产环境或复杂应用，建议使用数据库进行数据管理以提高可靠性和性能。

使用 `GORM` 简化了与 `SQLite` 数据库的交互，使得代码更简洁、更易读。`GORM` 提供了许多高级特性，如自动迁移、预加载、事务支持等，可以显著提高开发效率。如果你正在开发一个需要与关系型数据库频繁交互的应用，使用`ORM`框架是一个明智的选择。