Go语言学习(十)--MySql、MangoDB

一啊鸭0402

已于 2023-10-28 11:09:55 修改

阅读量103

点赞数

文章标签：学习 mysql 数据库

于 2023-10-28 11:08:12 首次发布

本文链接：https://blog.csdn.net/qq_56540305/article/details/134082762

版权

一、准备数据库和表

数据库使用的是MYSQL

创建了新的表，并添加了一些信息

二、安装配置mysql驱动

1、import包

import (
	"database/sql"
	_ "github.com/go-sql-driver/mysql"
)

2、初始化mod

go mod init study

3、使用mod自动导包

go mod tidy

三、数据库相关操作

3.1、数据库连接

package main

import (
	"database/sql"
	"fmt"
	_ "github.com/go-sql-driver/mysql"
)

/*
mysql
*/

// 数据库连接
var db *sql.DB

func initDB() (err error) {
	dsn := "root:123456@tcp(127.0.0.1:3306)/go_study?charset=utf8mb4&parseTime=True"
	//不会校验密码是否正确
	//这里不要使用:=，我们是给全局变量赋值，然后在main函数中使用全局变量db
	db, err = sql.Open("mysql", dsn)
	if err != nil {
		return err
	}
	//尝试与数据库建立连接(校验dsn是否正确)
	err = db.Ping()
	if err != nil {
		return err
	}
	return nil

	//
	最大连接时常
	//db.SetConnMaxLifetime(time.Minute * 3)
	最大连接数
	//db.SetMaxOpenConns(10)
	空闲连接数
	//db.SetMaxIdleConns(10)
}

func main() {
	err := initDB()
	if err != nil {
		fmt.Printf("err:%v\n", err)
	} else {
		println("连接成功")
	}

}

3.2、插入数据

插入、更新和删除都是用Exec方法

// 插入数据
func testAdd() {
	s := "insert into user_tb1 (username,password) values (?,?)"
	r, err := db.Exec(s, "zhangsan", "123456")
	if err != nil {
		fmt.Printf("err:%v\n", err)
	} else {
		i, _ := r.LastInsertId() //获得新插入的id
		fmt.Printf("i:%v\n", i)
	}
}

// 将插入包装成函数
func Insert(username string, password string) {
	s := "insert into user_tb1 (username,password) values (?,?)"
	r, err := db.Exec(s, username, password)
	if err != nil {
		fmt.Printf("err:%v\n", err)
	} else {
		i, _ := r.LastInsertId() //获得新插入的id
		fmt.Printf("i:%v\n", i)
	}
}

3.3、查询

单行查询

多行查询

示例

// 单行查询
func queryOneRow() {
	s := "select * from user_tb1 where id=?"
	var u User
	err := db.QueryRow(s, 1).Scan(&u.id, &u.username, &u.password) //记住一定是取地址
	if err != nil {
		fmt.Printf("err:%v\n", err)
	} else {
		fmt.Printf("u:%v\n", u)
	}
}

// 多行查询
func queryManyRow() {
	var u User
	s := "select * from user_tb1 where id>?"
	rows, err := db.Query(s, 0)
	defer rows.Close()
	if err != nil {
		fmt.Printf("err:%v\n", err)
	} else {
		for rows.Next() {
			err := rows.Scan(&u.id, &u.username, &u.password)
			if err != nil {
				fmt.Printf("err:%v\n", err)
			} else {
				fmt.Printf("u:%v\n", u)
			}
		}
	}
}

/*
u:{1 tom 123}
u:{2 tony 1234}
u:{3 kite 456}
u:{4 zhangsan 123456}
u:{5 zhangsan 123456}
u:{6 lisi lisi123}
*/

3.4、更新数据

// 更新数据
func testUpdate() {
	s := "update go_study.user_tb1 set username=?,password=? where id=?"
	r, err := db.Exec(s, "big kite1", "456789", 2)
	if err != nil {
		fmt.Printf("err:%v\n", err)
	} else {
		i, _ := r.RowsAffected()
		fmt.Printf("i:%v\n", i)
	}

}

3.5、删除数据

// 删除数据
func testDelete() {
	s := "delete from user_tb1 where id=?"
	ret, err := db.Exec(s, 4)
	if err != nil {
		fmt.Printf("err:%v\n", err)
		return
	} else {
		rows, err := ret.RowsAffected()
		if err != nil {
			fmt.Printf("删除行失败，err:%v\n", err)
			return
		} else {
			fmt.Printf("删除行成功，删除的行数：%v\n", rows)
		}
	}
}

总代码

package main

import (
	"database/sql"
	"fmt"
	_ "github.com/go-sql-driver/mysql"
)

/*
mysql
*/

// 数据库连接
var db *sql.DB

func initDB() (err error) {
	dsn := "root:123456@tcp(127.0.0.1:3306)/go_study?charset=utf8mb4&parseTime=True"
	//不会校验密码是否正确
	//这里不要使用:=，我们是给全局变量赋值，然后在main函数中使用全局变量db
	db, err = sql.Open("mysql", dsn)
	if err != nil {
		return err
	}
	//尝试与数据库建立连接(校验dsn是否正确)
	err = db.Ping()
	if err != nil {
		return err
	}
	return nil

	//
	最大连接时常
	//db.SetConnMaxLifetime(time.Minute * 3)
	最大连接数
	//db.SetMaxOpenConns(10)
	空闲连接数
	//db.SetMaxIdleConns(10)
}

// 插入数据
func testAdd() {
	s := "insert into user_tb1 (username,password) values (?,?)"
	r, err := db.Exec(s, "zhangsan", "123456")
	if err != nil {
		fmt.Printf("err:%v\n", err)
	} else {
		i, _ := r.LastInsertId() //获得新插入的id
		fmt.Printf("i:%v\n", i)
	}
}

// 将插入包装成函数
func Insert(username string, password string) {
	s := "insert into user_tb1 (username,password) values (?,?)"
	r, err := db.Exec(s, username, password)
	if err != nil {
		fmt.Printf("err:%v\n", err)
	} else {
		i, _ := r.LastInsertId() //获得新插入的id
		fmt.Printf("i:%v\n", i)
	}
}

// 定义一个结构体，用来接受查询出的内容。相当于cpp里面的对象
type User struct {
	id       int
	username string
	password string
}

// 单行查询
func queryOneRow() {
	s := "select * from user_tb1 where id=?"
	var u User
	err := db.QueryRow(s, 1).Scan(&u.id, &u.username, &u.password) //记住一定是取地址
	if err != nil {
		fmt.Printf("err:%v\n", err)
	} else {
		fmt.Printf("u:%v\n", u)
	}
}

// 多行查询
func queryManyRow() {
	var u User
	s := "select * from user_tb1 where id>?"
	rows, err := db.Query(s, 0)
	defer rows.Close()
	if err != nil {
		fmt.Printf("err:%v\n", err)
	} else {
		for rows.Next() {
			err := rows.Scan(&u.id, &u.username, &u.password)
			if err != nil {
				fmt.Printf("err:%v\n", err)
			} else {
				fmt.Printf("u:%v\n", u)
			}
		}
	}
}

/*
u:{1 tom 123}
u:{2 tony 1234}
u:{3 kite 456}
u:{4 zhangsan 123456}
u:{5 zhangsan 123456}
u:{6 lisi lisi123}
*/

// 更新数据
func testUpdate() {
	s := "update go_study.user_tb1 set username=?,password=? where id=?"
	r, err := db.Exec(s, "big kite1", "456789", 2)
	if err != nil {
		fmt.Printf("err:%v\n", err)
	} else {
		i, _ := r.RowsAffected()
		fmt.Printf("i:%v\n", i)
	}

}

// 删除数据
func testDelete() {
	s := "delete from user_tb1 where id=?"
	ret, err := db.Exec(s, 4)
	if err != nil {
		fmt.Printf("err:%v\n", err)
		return
	} else {
		rows, err := ret.RowsAffected()
		if err != nil {
			fmt.Printf("删除行失败，err:%v\n", err)
			return
		} else {
			fmt.Printf("删除行成功，删除的行数：%v\n", rows)
		}
	}
}
func main() {
	err := initDB()
	if err != nil {
		fmt.Printf("err:%v\n", err)
	} else {
		println("连接成功")
	}
	//testAdd()
	//Insert("lisi", "lisi123")
	//queryOneRow() //u:{1 tom 123}
	//queryManyRow()
	//testUpdate()
	testDelete() //删除行成功，删除的行数：1

}

四、golang操作MongoDB

4.1、下载安装驱动并且连接数据库

下载地址

Download MongoDB Community Server | MongoDB

推荐mongoDB下载表5.0版本，其他版本会出错

第一次下载的7.0版本，在打开时出现错误

打开客户端

注意目录

创建数据库

创建连接

这些都可以在可视化界面上完成

在goland上导入mongo包

 go get go.mongodb.org/mongo-driver/mongo

编写代码，完成连接

package main

import (
	"context"
	"fmt"
	_ "github.com/go-sql-driver/mysql"
	"go.mongodb.org/mongo-driver/mongo"
	"go.mongodb.org/mongo-driver/mongo/options"
	"log"
)

/*
mysql
*/
var client *mongo.Client //创建一个mongo客户端对象

func initDB() {
	//设置客户端连接配置
	uri := options.Client().ApplyURI("mongodb://localhost:27017")
	//连接到mongoDB
	connect, err := mongo.Connect(context.TODO(), uri)
	if err != nil {
		log.Fatal(err)
	}
	//检查连接
	err2 := connect.Ping(context.TODO(), nil)
	if err2 != nil {
		log.Fatal(err2)
	} else {
		fmt.Println("连接成功")
	}
    client=connect
}
func main() {
	initDB()
}

注意：这里的ApplyURI("mongodb:localhost:27017")对应着mongodb可视化界面左上角

4.2 BSON简介

MongoDB中的JSON文档存储在名为BSON(二进制编码的JSON)二进制表示中。与其他将JSON数据存储为简单字符串和数字的数据库不同。BSON编码扩展了JSON表示，使其包含额外的类型，如int、long、data、浮点数和decimal128.这使得应用程序更容易可靠的处理、排序和比较数据

连接MongoDB的GO驱动程序中有一个常用的类型表示BSON：D

类型D家族被用来简洁的构建使用本地GO类型的BSON对象，这对于构造传递给MongoDB的命令特别有用。D家族包括四类

D：一个BSON文档。这种类型应该在顺序重要的情况下使用。比如MongoDB命令
M：一张无序的map。他和D是一样的，只是他不保持顺序
A：一个BSON数组
E：D里面的一个元素

示例

package main

import (
	"fmt"
	_ "github.com/go-sql-driver/mysql"
	"go.mongodb.org/mongo-driver/bson"
)

/*
mysql
*/

func main() {
	//过滤器--相当于sql里面的where子句
	d := bson.D{
		{"name", "tom"},
	}
	fmt.Printf("d:%v\n", d)
}

4.3 操作

4.3.1添加文档

主要使用方法为

collection.InsertOne(context.TODO(), s1)。s1类型是结构体
collection.InsertMany(context.TODO(), stus)。stus类型是[]interface{}

package main

import (
	"context"
	"fmt"
	_ "github.com/go-sql-driver/mysql"
	"go.mongodb.org/mongo-driver/mongo"
	"go.mongodb.org/mongo-driver/mongo/options"
	"log"
)

type Student struct {
	Name string
	Age  int
}

var client *mongo.Client

// 初始化数据库
func initDB() {
	//设置客户端连接配置
	uri := options.Client().ApplyURI("mongodb://localhost:27017")
	//连接到mongoDB
	connect, err := mongo.Connect(context.TODO(), uri)
	if err != nil {
		log.Fatal(err)
	}
	//检查连接
	err2 := connect.Ping(context.TODO(), nil)
	if err2 != nil {
		log.Fatal(err2)
	} else {
		fmt.Println("连接成功")
	}
	client = connect

}

// 添加一条
func insert() {
	s1 := Student{
		Name: "tom",
		Age:  20,
	}
	collection := client.Database("golang_db").Collection("student")
	oneResult, err := collection.InsertOne(context.TODO(), s1)
	if err != nil {
		log.Fatal(err)
	} else {
		fmt.Printf("onResultId:%v\n", oneResult.InsertedID) //onResultId:ObjectID("653c640ba7b9c229ecda663e")

	}
}

// 添加多条记录
func insertMany() {
	collection := client.Database("golang_db").Collection("student")
	s1 := Student{
		Name: "tony",
		Age:  21,
	}
	s2 := Student{
		Name: "kite",
		Age:  22,
	}
	stus := []interface{}{s1, s2}
	//func (coll *Collection) InsertMany(ctx context.Context, documents []interface{}, opts ...*options.InsertManyOptions)
	//可以看到第二个参数是一个interface{}切片类型
	many, err := collection.InsertMany(context.TODO(), stus)
	if err != nil {
		log.Fatal(err)
	} else {
		fmt.Printf("manyResultId:%v\n", many.InsertedIDs)
	}
}
func main() {
	initDB()
	//insert()
	insertMany() //manyResultId:[ObjectID("653c65b674701f20ab8d5dc1") ObjectID("653c65b674701f20ab8d5dc2")]
}

查看添加结果：

方法一：

方法二：

可视化界面点击find按钮

4.3.2、查询

cur, err := collection.Find(ctx, bson.D{}) 
//查找全部的话，这里的bson就是空。相当于where
//cur 是一个游标，可以遍历。记住最后要关掉

func find() {
	ctx := context.TODO()
	defer client.Disconnect(ctx) //查完之后把连接关掉
	collection := client.Database("golang_db").Collection("student")
	cur, err := collection.Find(ctx, bson.D{}) //查找全部的话，这里的bson就是空。相当于where
	//cur 是一个游标，可以遍历。记住最后要关掉
	if err != nil {
		log.Fatal(err)
	}
	defer cur.Close(ctx)
	for cur.Next(ctx) {
		var result bson.D
		cur.Decode(&result)
		//理解：result是bson.D类型，可以理解为json类型。cur解码后传给result接受
		//前面我们知道D有很多类型。其中一种是map。这里就是map
		fmt.Printf("result:%v\n", result)
		//map
		fmt.Printf("result:%v\n", result.Map())
	}

}

4.3.3、查询

使用collection.UpdateMany()方法。

func update() {
	collection := client.Database("golang_db").Collection("student")
	update := bson.D{{"$set", bson.D{{"name", "big kite"}, {"age", 22}}}}
	many, err := collection.UpdateMany(context.TODO(), bson.D{{"name", "kite"}}, update)
	//将一个name为kite的人的名字修改为big kite，年龄修改为20
	if err != nil {
		log.Fatal(err)
	}
	println("修改了几条：", many.MatchedCount)
}

注意bson.D里面的name、age等等要和数据库对应。如果不是name而是Name的话，就会修改错误

4.3.4、删除

使用方法：collection.DeleteMany(context.TODO(), bson.D{{"name", "tom"}})

同样注意大小写

func del() {
	collection := client.Database("golang_db").Collection("student")
	many, err := collection.DeleteMany(context.TODO(), bson.D{{"name", "tom"}})
	//删除的是name为tom的数据
    if err != nil {
		log.Fatal(err)
	} else {
		println("删除了几条", many.DeletedCount)
	}
}

4.3.5、总代码

package main

import (
	"context"
	"fmt"
	_ "github.com/go-sql-driver/mysql"
	"go.mongodb.org/mongo-driver/bson"
	"go.mongodb.org/mongo-driver/mongo"
	"go.mongodb.org/mongo-driver/mongo/options"
	"log"
)

type Student struct {
	Name string
	Age  int
}

var client *mongo.Client

// 初始化数据库
func initDB() {
	//设置客户端连接配置
	uri := options.Client().ApplyURI("mongodb://localhost:27017")
	//连接到mongoDB
	connect, err := mongo.Connect(context.TODO(), uri)
	if err != nil {
		log.Fatal(err)
	}
	//检查连接
	err2 := connect.Ping(context.TODO(), nil)
	if err2 != nil {
		log.Fatal(err2)
	} else {
		fmt.Println("连接成功")
	}
	client = connect

}

// 添加一条
func insert() {
	s1 := Student{
		Name: "tom",
		Age:  20,
	}
	collection := client.Database("golang_db").Collection("student")
	oneResult, err := collection.InsertOne(context.TODO(), s1)
	if err != nil {
		log.Fatal(err)
	} else {
		fmt.Printf("onResultId:%v\n", oneResult.InsertedID) //onResultId:ObjectID("653c640ba7b9c229ecda663e")

	}
}

// 添加多条记录
func insertMany() {
	collection := client.Database("golang_db").Collection("student")
	s1 := Student{
		Name: "tony",
		Age:  21,
	}
	s2 := Student{
		Name: "kite",
		Age:  22,
	}
	stus := []interface{}{s1, s2}
	//func (coll *Collection) InsertMany(ctx context.Context, documents []interface{}, opts ...*options.InsertManyOptions)
	//可以看到第二个参数是一个interface{}切片类型
	many, err := collection.InsertMany(context.TODO(), stus)
	if err != nil {
		log.Fatal(err)
	} else {
		fmt.Printf("manyResultId:%v\n", many.InsertedIDs)
	}
}

// 查找---查所有
func find() {
	ctx := context.TODO()
	defer client.Disconnect(ctx) //查完之后把连接关掉
	collection := client.Database("golang_db").Collection("student")
	cur, err := collection.Find(ctx, bson.D{}) //查找全部的话，这里的bson就是空。相当于where
	//cur 是一个游标，可以遍历。记住最后要关掉
	if err != nil {
		log.Fatal(err)
	}
	defer cur.Close(ctx)
	for cur.Next(ctx) {
		var result bson.D
		cur.Decode(&result)
		//理解：result是bson.D类型，可以理解为json类型。cur解码后传给result接受
		//前面我们知道D有很多类型。其中一种是map。这里就是map
		fmt.Printf("result:%v\n", result)
		//map
		fmt.Printf("result:%v\n", result.Map())
	}

}

// 更新文档
func update() {
	collection := client.Database("golang_db").Collection("student")
	update := bson.D{{"$set", bson.D{{"name", "big kite"}, {"age", 22}}}}
	many, err := collection.UpdateMany(context.TODO(), bson.D{{"name", "kite"}}, update)
	//将一个name为kite的人的名字修改为big kite，年龄修改为20
	if err != nil {
		log.Fatal(err)
	}
	println("修改了几条：", many.MatchedCount)
}

// 删除
func del() {
	collection := client.Database("golang_db").Collection("student")
	many, err := collection.DeleteMany(context.TODO(), bson.D{{"name", "tom"}})
	if err != nil {
		log.Fatal(err)
	} else {
		println("删除了几条", many.DeletedCount)
	}
}
func main() {
	initDB()
	//insert()
	//insertMany() //manyResultId:[ObjectID("653c65b674701f20ab8d5dc1") ObjectID("653c65b674701f20ab8d5dc2")]
	//find()
	//update()
	del()
}

一啊鸭0402

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
Go语言学习(十)--MySql、MangoDB

MongoDB中的JSON文档存储在名为BSON(二进制编码的JSON)二进制表示中。与其他将JSON数据存储为简单字符串和数字的数据库不同。BSON编码扩展了JSON表示，使其包含额外的类型，如int、long、data、浮点数和decimal128.这使得应用程序更容易可靠的处理、排序和比较数据D类型D家族被用来简洁的构建使用本地GO类型的BSON对象，这对于构造传递给MongoDB的命令特别有用。D家族包括四类D：一个BSON文档。这种类型应该在顺序重要的情况下使用。比如MongoDB命令。
复制链接

扫一扫