kingcwt
Appearance

go笔记2

kingcwt2023-07-03前端golang

go笔记2

mySQL数据库-准备数据库和表

下载mysql

https://dev.mysql.com/downloads/mysql/

mysql -uroot -p
// 使用用户名 "root" 连接到 MySQL 数据库

create database go_db;
// 创建go_db数据库

use go_db;
// 打开数据库

desc user_tbl;
// 查看表

insert into user_tbl(username, password) values("kingchr","2134");
// 插入一条记录内容

select * from user_tbl;
//查看表中的所有数据

创建表

CREATE TABLE user_tbl(
id INTEGER PRIMARY KEY AUTO_INCREMENT,
username VARCHAR (20),
password VARCHAR (20),
)
// create table user_tbl(id integer primary key auto_increment, username varchar(20), password varchar(20));
  • select * from user_tbl;
  • desc user_tbl;

golang操作mysql数据库-安装mysql驱动

安装驱动

go get -u github.com/go-sql-driver/mysql

初始化模块

go mod init m

执行go mod tidy

go mod tidy

导入驱动

package main

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

golang操作mysql数据库

package mmysql

import (
	"database/sql"
	"fmt"
	"time"

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

// 定义一个全局对象db
var db *sql.DB

// 定义一个初始化数据库的函数
func intDB() (err error) {
	dsn := "root:password@tcp(127.0.0.1:3306)/go_db?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
}

func testDB() {
	db, err := sql.Open("mysql", "root:xx@qq.com@/go_db")
	if err != nil {
		panic(err)
	}

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

	fmt.Printf("db: %v\n", db)
}
func TestMySqlMain() {
	err := intDB()
	if err != nil {
		fmt.Printf("ERR: %v\n", err)
	} else {
		fmt.Println("连接成功！")
	}
}

golang操作mysql -【查询，新增，更新，删除】

package mmysql

import (
	"database/sql"
	"fmt"
	"time"

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

// 定义一个全局对象db
var db *sql.DB

func testDB() {
	db, err := sql.Open("mysql", "xx@qq.com:xx@qq.com@/go_db")
	if err != nil {
		panic(err)
	}

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

	fmt.Printf("db: %v\n", db)
}

// todo: 定义一个初始化数据库的函数
func intDB() (err error) {
	dsn := "root:password@tcp(127.0.0.1:3306)/go_db?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
}

// todo: 新增一条记录
func insert(username string, password string) {
	s := "insert into user_tbl(username, password) values(?,?)"
	r, err := db.Exec(s, username, password)
	if err != nil {
		fmt.Printf("err: %v\n", err)
	} else {
		i, _ := r.LastInsertId()
		fmt.Printf("id: %v\n", i)

	}

}

type User struct {
	id       int
	username string
	password string
}

// todo: 查询一条记录
func queryOneRow(id int) {
	s := "select * from user_tbl where id = ?"
	var u User
	err := db.QueryRow(s, id).Scan(&u.id, &u.username, &u.password)
	if err != nil {
		fmt.Printf("ERR: %v\n", err)
	} else {
		fmt.Printf("U: %v\n", u)
	}

}

// todo: 查询多条记录
func queryMultiRow() {
	s := "select * from user_tbl"
	r, err := db.Query(s)
	defer r.Close()
	var u User
	if err != nil {
		fmt.Printf("err: %v\n", err)
	} else {
		for r.Next() {
			err2 := r.Scan(&u.id, &u.username, &u.password)
			if err2 != nil {
				fmt.Printf("err2: %v\n", err2)
			} else {
				fmt.Printf("u: %v\n", u)
			}
		}
	}
}

// todo: 更新某条记录
func update(username string, password string, id int) {
	s := "update user_tbl set username=?, password=? where id=?"
	r, err := db.Exec(s, username, password, id)
	if err != nil {
		fmt.Printf("err: %v\n", err)
	} else {
		i, _ := r.RowsAffected()
		fmt.Printf("i: %v\n", i)
	}
}

// todo: 删除某条记录
func delete(id int) {
	s := "delete from user_tbl where id=?"
	r, err := db.Exec(s, id)
	if err != nil {
		fmt.Printf("err: %v\n", err)
	} else {
		i, _ := r.RowsAffected()
		fmt.Printf("i: %v\n", i)
	}
}
func TestMySqlMain() {
	err := intDB()
	if err != nil {
		fmt.Printf("ERR: %v\n", err)
	} else {
		fmt.Println("连接成功！")
		delete(1)
	}
}

golang操作-MongoDB

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

连接MongoDB的Go驱动程序中有两大类型表示BSON数据:D和Raw

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

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

在go中安装MongoDB驱动

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

要使用BSON,需要先导入下面的包:

import "go.mongodb.org/mongo-driver/bson"

下面是一个使用D类型构建的过滤器文档的例子,它可以用来查找name字段与张三或李四匹配的文档:

bson.D({
"name",
bson.D{{
  "$in",
  bson.A{"张三","李四"}
}}
})

Raw类型家族用于验证字节切片.你还可以使用Lookup()从原始类型检索单个元素,如果你不想要将BSON反序列化成另一种类型的开销,那么这是非常有用的

  • MongoDB Shell
// 命令行执行 
mongosh  // 连接mongodb
// 新建一个数据库
use go_db;
// 在users集合中插入一条数据
db.users.insertOne({name:"cwt",age:"27"})
// 查找users集合下的数据
db.users.find()
// 删除users集合
db.users.drop()
// 删除当前数据库
use go_db;
db.dropDatabase()
  • 查看更多：

Insert Documentsopen in new window

MongoDB-CRUD操作

package mmongodb

import (
	"context"
	"fmt"
	"log"

	"go.mongodb.org/mongo-driver/bson"
	"go.mongodb.org/mongo-driver/mongo"
	"go.mongodb.org/mongo-driver/mongo/options"
)

type Users struct {
	Name string
	Age  string
}

var client *mongo.Client

// 初始化mongodb数据库连接
func initDB() {
	clientOptions := options.Client().ApplyURI("mongodb://localhost:27017")
	var err error
	client, err = mongo.Connect(context.TODO(), clientOptions) // context.TODO() 表示一个占位 空的上下文 ；context.Background() 具有超时和取消的功能
	if err != nil {
		fmt.Printf("客户端连接err: %v\n", err)
		log.Fatal(err)
	}
	err2 := client.Ping(context.TODO(), nil)
	if err2 != nil {
		log.Fatal(err2)
	} else {
		fmt.Println("连接成功!")
	}
}

// 插入一条数据
func insert(name string, age string) {
	initDB()
	c1 := Users{
		name,
		age,
	}
	c := client.Database("go_db").Collection("Users")
	ior, err := c.InsertOne(context.TODO(), c1)
	if err != nil {
		fmt.Printf("err: %v\n", err)
	} else {
		fmt.Printf("ior.InsertedID: %v\n", ior.InsertedID)
	}
}

// 插入多条数据
func insertMany(name1 string, age1 string, name2 string, age2 string) {
	initDB()
	s1 := Users{
		name1,
		age1,
	}
	s2 := Users{
		name2,
		age2,
	}
	us := []interface{}{s1, s2}
	c := client.Database("go_db").Collection("Users")
	imr, err := c.InsertMany(context.TODO(), us)
	if err != nil {
		fmt.Printf("err: %v\n", err)
	} else {
		fmt.Printf("imr.InsertedIDs: %v\n", imr.InsertedIDs)
	}
}

// 查询多条数据
func findMany() {
	initDB()
	ctx := context.TODO()
	defer client.Disconnect(ctx)
	c := client.Database("go_db").Collection("Users")
	c2, err := c.Find(ctx, bson.D{})
	if err != nil {
		log.Fatal(err)
	}
	defer c2.Close(ctx)

	for c2.Next(ctx) {
		var result bson.D
		c2.Decode(&result)
		fmt.Printf("result: %v\n", result)
		fmt.Printf("result.Map(): %v\n", result.Map())
	}
}

// 查询一条
func find() {
	initDB()
	ctx := context.TODO()
	defer client.Disconnect(ctx)
	c := client.Database("go_db").Collection("Users")
	c2, err := c.Find(ctx, bson.M{"name": "a1"}) // 使用 bson.M 表示匹配的查询条件
	if err != nil {
		log.Fatal(err)
	}
	defer c2.Close(ctx)

	var results []Users
	if err := c2.All(ctx, &results); err != nil {
		log.Fatal(err)
	}

	for _, result := range results {
		fmt.Printf("result: %+v\n", result)
	}
}

// 更新这一项
func updateOne() {
	initDB()
	c := client.Database("go_db").Collection("Users")
	ctx := context.TODO()
	update := bson.D{{Key: "$set", Value: bson.D{{Key: "name", Value: "big-kingchr"}, {Key: "age", Value: "27"}}}}
	ur, err := c.UpdateOne(ctx, bson.D{{Key: "name", Value: "kingchr"}}, update)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("ur.ModifiedCount: %v\n", ur.ModifiedCount)
}

// 更新多条
func updateMany() {
	initDB()
	c := client.Database("go_db").Collection("Users")
	ctx := context.TODO()
	update := bson.D{{Key: "$set", Value: bson.D{{Key: "name", Value: "big-a1"}, {Key: "age", Value: "18"}}}}
	ur, err := c.UpdateMany(ctx, bson.D{{Key: "name", Value: "a1"}}, update)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("ur.ModifiedCount: %v\n", ur.ModifiedCount)
}

// 删除一条
func delOne() {
	initDB()
	c := client.Database("go_db").Collection("Users")
	ctx := context.TODO()
	dr, err := c.DeleteOne(ctx, bson.D{{Key: "age", Value: "20"}})
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("dr.DeletedCount: %v\n", dr.DeletedCount)
}

// 删除多条
func delMany() {
	initDB()
	c := client.Database("go_db").Collection("Users")
	ctx := context.TODO()
	dr, err := c.DeleteMany(ctx, bson.D{{Key: "name", Value: "a5"}})
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("dr.DeletedCount: %v\n", dr.DeletedCount)
}

func TestMongoDBMain() {
	// insert("kingchr", "18")
	// insertMany("a5", "10", "a5", "20")
	delMany()
}

package main

import (
	"go3/mmongodb"
)

func main() {
	mmongodb.TestMongoDBMain()
}
Last Updated 10/16/2023, 7:06:22 AM
What do you think?
  • 0
  • 0
  • 0
  • 0
  • 0
  • 0
0  Words
Comments
  • Latest
  • Oldest
  • Hottest
Powered by Waline v2.15.8
ON THIS PAGE