GVKun编程网logo

golang - gorm

15

如果您对golang-gorm感兴趣，那么这篇文章一定是您不可错过的。我们将详细讲解golang-gorm的各种细节，此外还有关于GOLANGBEEGOORM、GolangGormFiber/argo

如果您对golang - gorm感兴趣，那么这篇文章一定是您不可错过的。我们将详细讲解golang - gorm的各种细节，此外还有关于GOLANG BEEGO ORM、Golang Gorm Fiber / argon2.Config 未定义、golang gorm 基本使用、golang gorm 操作mysql及gorm基本用法的实用技巧。

本文目录一览：

golang - gorm

golang - gorm

gorm github、 gitbook

概述

package main

import (
	"github.com/jinzhu/gorm"
	_ "github.com/jinzhu/gorm/dialects/mysql"
)

type Product struct {
	ID uint `gorm:"primary_key"`
	Code string
	Price uint
}

func main() {
	db,err := gorm.Open("mysql","user:password@/dbname?charset=utf8&parseTime=True&loc=Local")
	if err != nil {
		panic("failed to connect database")
	}
	defer db.Close()

	// 自动迁移表，生成的表名为 products
	db.AutoMigrate(&Product{})

	// Create
	db.Create(&Product{Code: "L1212", Price: 1000})

	// Read
	var product Product
	db.First(&product, 1) // find product with id 1
	db.First(&product, "code = ?", "L1212") // find product with code l1212

	// Update
	db.Model(&product).Update("Price", 2000)

	 //Delete
	db.Delete(&product)

}

模型定义

4 个特殊字段。其中 ID 字段默认为主键字段，可以无需加 Tag `gorm:"primary_key"`。

type Model struct { 
  ID        uint `gorm:"primary_key"`
  CreatedAt time.Time
  UpdatedAt time.Time
  DeletedAt *time.Time
}

使用 gorm.Model 自动生成这 4 个字段。效果等同上。

type User struct {
    gorm.Model
}

修改表名

type Product struct {
	ID    uint
	Code  string
	Price uint
}

//修改默认表名
func (Product) TableName() string {
	return "product2"
}

type Email struct {
	ID         int
	Email      string
}

func main() {
	db, err := gorm.Open("mysql", "root:root@tcp(localhost:3306)/gorm")
	if err != nil {
		panic("failed to connect database")
	}
	defer db.Close()

	//设置默认表名前缀
	gorm.DefaultTableNameHandler = func(db *gorm.DB, defaultTableName string) string {
		return "prefix_" + defaultTableName
	}

	//自动生成表
	db.AutoMigrate(&Product{}, &Email{})

}

设置字段 

type Product struct {
	ID    uint `gorm:"primary_key:id"`
	Num   int  `gorm:"AUTO_INCREMENT:number"`
	Code  string
	Price uint  `gorm:"default:''1000''"`
	Tag   []Tag     `gorm:"many2many:tag;"`
	Date  time.Time `gorm:"-"`
}

type Email struct {
	ID         int    `gorm:"primary_key:id"`
	UserID     int    `gorm:"not null;index"`
	Email      string `gorm:"type:varchar(100);unique_index"`
	Subscribed bool
}

type Tag struct {
	Name string
}

func main() {
	db, err := gorm.Open("mysql", "root:root@tcp(localhost:3306)/gorm")
	if err != nil {
		panic("failed to connect database")
	}
	defer db.Close()

	gorm.DefaultTableNameHandler = func(db *gorm.DB, defaultTableName string) string {
		return "demo_" + defaultTableName
	}

	db.AutoMigrate(&Product{}, &Email{})

}

设置外键字段

type Profile struct {
	gorm.Model
	Refer int
	Name  string
}

type User struct {
	gorm.Model
	Profile   Profile `gorm:"ForeignKey:ProfileID;AssociationForeignKey:Refer"`
	ProfileID int
}

增删改查

增

type Animal struct {
    ID   int64
    Name string `gorm:"default:''galeone''"`
    Age  int64
}

var animal = Animal{Age: 99, Name: ""}
db.Create(&animal)

查

// SELECT * FROM users ORDER BY id LIMIT 1;
db.First(&user)

// SELECT * FROM users ORDER BY id DESC LIMIT 1;
db.Last(&user)

// SELECT * FROM users;
db.Find(&users)

// SELECT * FROM users WHERE id = 10;
db.First(&user, 10)

添加 where 子句

// Get first matched record
db.Where("name = ?", "jinzhu").First(&user)
//// SELECT * FROM users WHERE name = ''jinzhu'' limit 1;

// Get all matched records
db.Where("name = ?", "jinzhu").Find(&users)
//// SELECT * FROM users WHERE name = ''jinzhu'';

db.Where("name <> ?", "jinzhu").Find(&users)

// IN
db.Where("name in (?)", []string{"jinzhu", "jinzhu 2"}).Find(&users)

// LIKE
db.Where("name LIKE ?", "%jin%").Find(&users)

// AND
db.Where("name = ? AND age >= ?", "jinzhu", "22").Find(&users)

// Time
db.Where("updated_at > ?", lastWeek).Find(&users)

db.Where("created_at BETWEEN ? AND ?", lastWeek, today).Find(&users)

结构或者 map

// Struct
db.Where(&User{Name: "jinzhu", Age: 20}).First(&user)
//// SELECT * FROM users WHERE name = "jinzhu" AND age = 20 LIMIT 1;

// Map
db.Where(map[string]interface{}{"name": "jinzhu", "age": 20}).Find(&users)
////  SELECT * FROM users WHERE name = "jinzhu" AND age = 20;

// Slice of primary keys
db.Where([]int64{20, 21, 22}).Find(&users)
////  SELECT * FROM users WHERE id IN (20, 21, 22);

inline condition

// Get by primary key (only works for integer primary key)
db.First(&user, 23)
//// SELECT * FROM users WHERE id = 23 LIMIT 1;
// Get by primary key if it were a non-integer type
db.First(&user, "id = ?", "string_primary_key")
//// SELECT * FROM users WHERE id = ''string_primary_key'' LIMIT 1;

// Plain SQL
db.Find(&user, "name = ?", "jinzhu")
//// SELECT * FROM users WHERE name = "jinzhu";

db.Find(&users, "name <> ? AND age > ?", "jinzhu", 20)
//// SELECT * FROM users WHERE name <> "jinzhu" AND age > 20;

// Struct
db.Find(&users, User{Age: 20})
//// SELECT * FROM users WHERE age = 20;

// Map
db.Find(&users, map[string]interface{}{"age": 20})
//// SELECT * FROM users WHERE age = 20;

Select 选择

db.Select("name, age").Find(&users)
//// SELECT name, age FROM users;

db.Select([]string{"name", "age"}).Find(&users)
//// SELECT name, age FROM users;

db.Table("users").Select("COALESCE(age,?)", 42).Rows()
//// SELECT COALESCE(age,''42'') FROM users;

排序

db.Order("age desc, name").Find(&users)
//// SELECT * FROM users ORDER BY age desc, name;

// Multiple orders
db.Order("age desc").Order("name").Find(&users)
//// SELECT * FROM users ORDER BY age desc, name;

// ReOrder
db.Order("age desc").Find(&users1).Order("age", true).Find(&users2)
//// SELECT * FROM users ORDER BY age desc; (users1)
//// SELECT * FROM users ORDER BY age; (users2)

limit 子句

db.Limit(3).Find(&users)
//// SELECT * FROM users LIMIT 3;

// Cancel limit condition with -1
db.Limit(10).Find(&users1).Limit(-1).Find(&users2)
//// SELECT * FROM users LIMIT 10; (users1)
//// SELECT * FROM users; (users2)

count

db.Model(&User{}).Where("name = ?", "jinzhu").Count(&count)
//// SELECT count(*) FROM users WHERE name = ''jinzhu''; (count)

db.Table("deleted_users").Count(&count)
//// SELECT count(*) FROM deleted_users;

group & having

type Result struct {
    Date  time.Time
    Total int64
}
db.Table("orders").Select("date(created_at) as date, sum(amount) as total").Group("date(created_at)").Having("sum(amount) > ?", 100).Scan(&results)

Joins

db.Table("users").Select("users.name, emails.email").Joins("left join emails on emails.user_id = users.id").Scan(&results)

Scan

type Result struct {
    Name string
    Age  int
}

var result Result
db.Table("users").Select("name, age").Where("name = ?", 3).Scan(&result)

// Raw SQL
db.Raw("SELECT name, age FROM users WHERE name = ?", 3).Scan(&result)

指定表名

// Create `deleted_users` table with struct User''s definition
db.Table("deleted_users").CreateTable(&User{})

改

save 全部更新

db.First(&user)

user.Name = "jinzhu 2"
user.Age = 100
db.Save(&user)

//// UPDATE users SET name=''jinzhu 2'', age=100, birthday=''2016-01-01'', updated_at = ''2013-11-17 21:34:10'' WHERE id=111;

部分更新

db.Model(&user).Update("name", "hello")
db.Model(&user).Updates(User{Name: "hello", Age: 18})

对更新语句进行 select 和 omit

db.Model(&user).Select("name").Updates(map[string]interface{}{"name": "hello", "age": 18, "actived": false})
//// UPDATE users SET name=''hello'', updated_at=''2013-11-17 21:34:10'' WHERE id=111;

db.Model(&user).Omit("name").Updates(map[string]interface{}{"name": "hello", "age": 18, "actived": false})
//// UPDATE users SET age=18, actived=false, updated_at=''2013-11-17 21:34:10'' WHERE id=111;

删

// Delete an existing record
db.Delete(&email)
//// DELETE from emails where id=10;

软删除

当设置 DeletedAt 字段时，默认不会真的删除该记录。只会把该记录的 DeletedAt 的值设置为当前时间。

// 执行软删除
db.Delete(&user)
//// UPDATE users SET deleted_at="2013-10-29 10:23" WHERE id = 111;

// 虽然记录没有永久删除。但是查询时依然不会查询到该记录
db.Where("age = 20").Find(&user)
//// SELECT * FROM users WHERE age = 20 AND deleted_at IS NULL;

// 可以通过指定域查询到该软删除的记录
db.Unscoped().Where("age = 20").Find(&users)
//// SELECT * FROM users WHERE age = 20;

// 通过指定域进行永久删除
db.Unscoped().Delete(&order)
//// DELETE FROM orders WHERE id=10;

子查询

db.Preload("Orders").Find(&users)
//// SELECT * FROM users;
//// SELECT * FROM orders WHERE user_id IN (1,2,3,4);

db.Preload("Orders", "state NOT IN (?)", "cancelled").Find(&users)
//// SELECT * FROM users;
//// SELECT * FROM orders WHERE user_id IN (1,2,3,4) AND state NOT IN (''cancelled'');

db.Where("state = ?", "active").Preload("Orders", "state NOT IN (?)", "cancelled").Find(&users)
//// SELECT * FROM users WHERE state = ''active'';
//// SELECT * FROM orders WHERE user_id IN (1,2) AND state NOT IN (''cancelled'');

db.Preload("Orders").Preload("Profile").Preload("Role").Find(&users)
//// SELECT * FROM users;
//// SELECT * FROM orders WHERE user_id IN (1,2,3,4); // has many
//// SELECT * FROM profiles WHERE user_id IN (1,2,3,4); // has one
//// SELECT * FROM roles WHERE id IN (4,5,6); // belongs to

db.Preload("Orders.OrderItems").Find(&users)
db.Preload("Orders", "state = ?", "paid").Preload("Orders.OrderItems").Find(&users)

关联存储

增和改时默认级联处理

user := User{
    Name:            "jinzhu",
    BillingAddress:  Address{Address1: "Billing Address - Address 1"},
    ShippingAddress: Address{Address1: "Shipping Address - Address 1"},
    Emails:          []Email{
                                        {Email: "jinzhu@example.com"},
                                        {Email: "jinzhu-2@example@example.com"},
                   },
    Languages:       []Language{
                     {Name: "ZH"},
                     {Name: "EN"},
                   },
}

db.Create(&user)
//// BEGIN TRANSACTION;
//// INSERT INTO "addresses" (address1) VALUES ("Billing Address - Address 1");
//// INSERT INTO "addresses" (address1) VALUES ("Shipping Address - Address 1");
//// INSERT INTO "users" (name,billing_address_id,shipping_address_id) VALUES ("jinzhu", 1, 2);
//// INSERT INTO "emails" (user_id,email) VALUES (111, "jinzhu@example.com");
//// INSERT INTO "emails" (user_id,email) VALUES (111, "jinzhu-2@example.com");
//// INSERT INTO "languages" ("name") VALUES (''ZH'');
//// INSERT INTO user_languages ("user_id","language_id") VALUES (111, 1);
//// INSERT INTO "languages" ("name") VALUES (''EN'');
//// INSERT INTO user_languages ("user_id","language_id") VALUES (111, 2);
//// COMMIT;

db.Save(&user)

取消默认关联存储

type User struct {
  gorm.Model
  Name      string
  CompanyID uint
  Company   Company `gorm:"save_associations:false"`
}

type Company struct {
  gorm.Model
  Name string
}

或着手动取消

db.Set("gorm:save_associations", false).Create(&user)

db.Set("gorm:save_associations", false).Save(&user)

 

表间关系

一对多关系

type User struct {
    gorm.Model
    Emails   []Email
}

type Email struct {
    gorm.Model
    Email   string
    UserID  uint
}

// 查询某userid为111的用户的所有Email 地址
db.Model(&user).Related(&emails)
//// SELECT * FROM emails WHERE user_id = 111; // 111 is user''s primary key

多对多关系

(相互关联）

type User struct {
    gorm.Model
    Languages         []Language `gorm:"many2many:user_languages;"`
}

type Language struct {
    gorm.Model
    Name string
    Users               []User     `gorm:"many2many:user_languages;"`
}

// 查询某语言为111的所有用户
db.Model(&language).Related(&users)
//// SELECT * FROM "users" INNER JOIN "user_languages" ON "user_languages"."user_id" = "users"."id" WHERE  ("user_languages"."language_id" IN (''111''))

（单一关联，比如个人与同学）

type User struct {
    gorm.Model
    Languages         []Language `gorm:"many2many:user_languages;"`
}

type Language struct {
    gorm.Model
    Name string
}

db.Model(&user).Related(&languages, "Languages")
//// SELECT * FROM "languages" INNER JOIN "user_languages" ON "user_languages"."language_id" = "languages"."id" WHERE "user_languages"."user_id" = 111

关联模式

（方便处理处理多对多）

// 开始关联
db.Model(&user).Association("Languages")


// 查询
db.Model(&user).Association("Languages").Find(&languages)


// 添加
db.Model(&user).Association("Languages").Append([]Language{languageZH, languageEN})
db.Model(&user).Association("Languages").Append(Language{Name: "DE"})


// 删除
db.Model(&user).Association("Languages").Delete([]Language{languageZH, languageEN})
db.Model(&user).Association("Languages").Delete(languageZH, languageEN)


// 更新
db.Model(&user).Association("Languages").Replace([]Language{languageZH, languageEN})
db.Model(&user).Association("Languages").Replace(Language{Name: "DE"}, languageEN)


db.Model(&user).Association("Languages").Count()


// 移除关联
db.Model(&user).Association("Languages").Clear()

 

高级用法

事务

func CreateAnimals(db *gorm.DB) err {
  tx := db.Begin()
  // Note the use of tx as the database handle once you are within a transaction

  if err := tx.Create(&Animal{Name: "Giraffe"}).Error; err != nil {
     tx.Rollback()
     return err
  }

  if err := tx.Create(&Animal{Name: "Lion"}).Error; err != nil {
     tx.Rollback()
     return err
  }

  tx.Commit()
  return nil
}

原生 sql

db.Exec("DROP TABLE users;")
db.Exec("UPDATE orders SET shipped_at=? WHERE id IN (?)", time.Now(), []int64{11,22,33})

// Scan
type Result struct {
    Name string
    Age  int
}

var result Result
db.Raw("SELECT name, age FROM users WHERE name = ?", 3).Scan(&result)

sql.DB 接口

// Get generic database object `*sql.DB` to use its functions
db.DB()

// Ping
db.DB().Ping()

db.DB().SetMaxIdleConns(10)
db.DB().SetMaxOpenConns(100)

日志处理

// Enable Logger, show detailed log
db.LogMode(true)

// Diable Logger, don''t show any log
db.LogMode(false)

// Debug a single operation, show detailed log for this operation
db.Debug().Where("name = ?", "jinzhu").First(&User{})

//默认 error，设置日志级别
db.SetLogger(gorm.Logger{revel.TRACE})

错误处理

// 一般处理
if err := db.Where("name = ?", "jinzhu").First(&user).Error; err != nil {
    // error handling...
}

// 获取所有的错误
db.First(&user).Limit(10).Find(&users).GetErrors()

// 获取记录找不到错误（不排除有其他错误）
db.Where("name = ?", "hello world").First(&user).RecordNotFound()

函数钩子

 阅读原文

GOLANG BEEGO ORM

GOLANG BEEGO ORM

GOLANG BEEGO ORM

每种语言一旦开始步入生产环节都不可避免对数据库操作，ORM 为业务逻辑与底层数据库操作建立起一座桥梁，使得业务对象能直接映射到数据库对象上，减少了数据库的误操作，同时也使得业务代码更加清晰。语言一旦开始成熟，都会有相应的 ORM 框架出现，这些框架大部分都是语言的第三方库。如同 JAVA 的 Hibernate、Mybatis，C#的 LINQ 等，GO语言也有一些 ORM 框架，这里根据个人使用经历对 BEEGO 的 ORM 框架从代码层面进行一个简单说明。

基本用法

  • 依赖库

    import "github.com/astaxie/beego/orm"
import _ "github.com/go-sql-driver/MysqL"

  • 映射对象定义

    type User struct { Id int `orm:"pk;auto"` Name string Age int Date time.Time }

    其中使用标注对主键进行声明，这里其实不声明也行，因为该框架默认使用Id作为主键

  • 初始化

orm.RegisterModel(new(User))  //注册表
    orm.RegisterDriver("MysqL",orm.DRMysqL)  //注册数据库驱动，这里用的MysqL
    orm.RegisterDataBase("default","MysqL","xxx:xxx@/xxx?charset=utf8")  //注册数据库
    orm.RunSyncdb("default",false,true)  //同步数据库，如果表不存在会自动创建
    orm.Debug = true  //是否输出调试信息
  • CURD
    这里就插入数据操作进行说明，其他类似
t := orm.NewOrm()
    t.Using("default")
    user := &User{Name: "hello",Age: 10,Date: time.Now()}
    t.Begin()
    _,err := t.Insert(user)
    if err != nil {
        fmt.Println(err)
        t.Rollback()
    } else {
        t.Commit()
    }

Golang Gorm Fiber / argon2.Config 未定义

Golang Gorm Fiber / argon2.Config 未定义

golang gorm fiber / argon2.config 未定义

php小编百草在使用Golang Gorm Fiber和argon2.Config时，可能会遇到"未定义"的问题。这个问题主要是由于缺少相应的定义或配置所导致的。要解决这个问题，我们需要检查相应的库和配置是否正确引入，并确保它们在代码中得到正确的使用和调用。通过仔细检查和调试，我们可以解决这个问题，让我们的代码能够正常运行。

问题内容

我正在尝试从 PHP 切换到 GO，但我陷入了困境，我请求您的帮助。

我正在尝试使用 Argon2 创建密码哈希函数，但当我使用“argon2.Config{}”时，我不断收到错误“未定义：argon2.Config”。我已经多次重新编译该项目，但似乎找不到解决方案。我请求您帮助解决此问题。

func hashPassword(password string) []byte {
    // Şifreleme parametreleri
    timeCost := 1                 // İşlem süresi
    memory := 64 * 1024           // // Bellek miktarı
    threads := 4                  //  İş parçacığı sayısı
    keyLength := 32               // Oluşturulacak hash uzunluğu
    salt := []byte("unique_salt") // Her kullanıcı için benzersiz

    // Argon2 işlemi için hasher oluştur
    hasher := argon2.Config{
        Time:    uint32(timeCost),
        Memory:  uint32(memory),
        Threads: uint8(threads),
        KeyLen:  uint32(keyLength),
    }

    // Şifreyi hashle
    hashedPassword := hasher.Hash(password, salt, nil)

    return hashedPassword
}
登录后复制

解决方法

如果您使用包 "golang.org/x/crypto/argon2" 您可以使用 argon2.IDKey() 方法。这是一个工作示例：

立即学习“go语言免费学习笔记（深入）”；

func HashPassword(password string) (hashedPassword string) {

    const (
        timeCost  uint32 = 1         // İşlem süresi
        memory    uint32 = 64 * 1024 // // Bellek miktarı
        threads   uint8  = 4         //  İş parçacığı sayısı
        keyLength uint32 = 32        // Oluşturulacak hash uzunluğu
    )

    salt := []byte("unique_salt") // Her kullanıcı için benzersiz

    // generate hashedpassword
    hash := argon2.IDKey([]byte(password), salt, timeCost, memory, threads, keyLength)

    // Base64 encode the salt and hashed password.
    b64Salt := base64.RawStdEncoding.EncodeToString(salt)
    b64Hash := base64.RawStdEncoding.EncodeToString(hash)

    format := "$argon2id$v=%d$models=%d,t=%d,p=%d$%s$%s"

    // final password in recommended format
    hashedPassword = fmt.Sprintf(format, argon2.Version, memory, timeCost, threads, b64Salt, b64Hash)
    return hashedPassword
}
登录后复制

以上就是Golang Gorm Fiber / argon2.Config 未定义的详细内容，更多请关注php中文网其它相关文章！

golang gorm 基本使用

golang gorm 基本使用

原文链接：golang orm 框架之 gorm

gorm 用法介绍

库安装

go get -u github.com/jinzhu/gorm

数据库连接

import (
    "github.com/jinzhu/gorm"
    _ "github.com/jinzhu/gorm/dialects/mysql"
）

var db *gorm.DB

func init() {
    var err error
    db, err = gorm.Open("mysql", "<user>:<password>/<database>?charset=utf8&parseTime=True&loc=Local")
    if err != nil {
        panic(err)
    }
}

连接比较简单，直接调用 gorm.Open 传入数据库地址即可

github.com/jinzhu/gorm/dialects/mysql 是 golang 的 mysql 驱动，实际上就是 github.com/go-sql-driver/mysql 作者这里为了好记，重新弄了个名字

这里我用的 mysql，实际上支持基本上所有主流的关系数据库，连接方式上略有不同

db.DB().SetMaxIdleConns(10)
db.DB().SetMaxOpenConns(100)

还可以使用 db.DB() 对象设置连接池信息

表定义

先来定义一个点赞表，这里面一条记录表示某个用户在某个时刻对某篇文章点了一个赞，用 ip + ua 来标识用户，title 标识文章标题

type Like struct {
    ID        int    `gorm:"primary_key"`
    Ip        string `gorm:"type:varchar(20);not null;index:ip_idx"`
    Ua        string `gorm:"type:varchar(256);not null;"`
    Title     string `gorm:"type:varchar(128);not null;index:title_idx"`
    Hash      uint64 `gorm:"unique_index:hash_idx;"`
    CreatedAt time.Time
}

gorm 用 tag 的方式来标识 mysql 里面的约束

创建索引只需要直接指定列即可，这里创建了两个索引，ip_idx 和 title_idx；如果需要多列组合索引，直接让索引的名字相同即可；如果需要创建唯一索引，指定为 unique_index 即可

支持时间类型，直接使用 time.Time 即可

创建表

if !db.HasTable(&Like{}) {
    if err := db.Set("gorm:table_options", "ENGINE=InnoDB DEFAULT CHARSET=utf8").CreateTable(&Like{}).Error; err != nil {
        panic(err)
    }
}

直接通过 db.CreateTable 就可以创建表了，非常方便，还可以通过 db.Set 设置一些额外的表属性

插入

like := &Like{
    Ip:        ip,
    Ua:        ua,
    Title:     title,
    Hash:      murmur3.Sum64([]byte(strings.Join([]string{ip, ua, title}, "-"))) >> 1,
    CreatedAt: time.Now(),
}

if err := db.Create(like).Error; err != nil {
    return err
}

先构造已给对象，直接调用 db.Create() 就可以插入一条记录了

删除

if err := db.Where(&Like{Hash: hash}).Delete(Like{}).Error; err != nil {
    return err
}

先用 db.Where() 构造查询条件，再调用 db.Delete() 就可以删除

查询

var count int
err := db.Model(&Like{}).Where(&Like{Ip: ip, Ua: ua, Title: title}).Count(&count).Error
if err != nil {
    return false, err
}

先用 db.Model() 选择一个表，再用 db.Where() 构造查询条件，后面可以使用 db.Count() 计算数量，如果要获取对象，可以使用 db.Find(&Likes) 或者只需要查一条记录 db.First(&Like)

修改

db.Model(&user).Update("name", "hello")
db.Model(&user).Updates(User{Name: "hello", Age: 18})
db.Model(&user).Updates(User{Name: "", Age: 0, Actived: false}) // nothing update

我这个系统里面没有更新需求，这几个例子来自于官网，第一个是更新单条记录；第二个是更新整条记录，注意只有非空字段才会更新；第三个例子是不会更新的，在系统设计的时候要尽量避免这些空值有特殊的含义，如果一定要更新，可以使用第一种方式，设置单个值

错误处理

其实你已经看到了，这里基本上所有的函数都是链式的，全部都返回 db 对象，任何时候调用 db.Error 就能获取到错误信息，非常方便

事务

func CreateAnimals(db *gorm.DB) err {
    tx := db.Begin()
    if err := tx.Create(&Animal{Name: "Giraffe"}).Error; err != nil {
        tx.Rollback()
        return err
    }
    if err := tx.Create(&Animal{Name: "Lion"}).Error; err != nil {
        tx.Rollback()
        return err
    }
    tx.Commit()
    return nil
}

事务的处理也很简单，用 db.Begin() 声明开启事务，结束的时候调用 tx.Commit()，异常的时候调用 tx.Rollback()

其他

还可以使用如下方式设置日志输出级别以及改变日志输出地方

db.LogMode(true)
db.SetLogger(gorm.Logger{revel.TRACE})
db.SetLogger(log.New(os.Stdout, "\r\n", 0))

也支持普通的 sql，但是建议尽量不要使用

参考链接

  • gorm 官方文档: http://gorm.io/
  • gorm github: https://github.com/jinzhu/gorm

golang gorm 操作mysql及gorm基本用法

golang gorm 操作mysql及gorm基本用法

golang 官方的那个操作mysql的有点麻烦所以就使用了gorm，下面就gorm的使用做下简单介绍

下载gorm：

go get -u github.com/jinzhu/gorm

在项目中引入gorm：

import (
 "github.com/jinzhu/gorm"
 _ "github.com/jinzhu/gorm/dialects/mysql"
)

定义db连接信息

func DbConn(MyUser, Password, Host, Db string, Port int) *gorm.DB {
 connArgs := fmt.Sprintf("%s:%s@(%s:%d)/%s?charset=utf8&parseTime=True&loc=Local", MyUser,Password, Host, Port, Db )
 db, err := gorm.Open("mysql", connArgs)
 if err != nil {
  log.Fatal(err)
 }
 db.SingularTable(true)
 return db
}

由于grom是使用的orm映射，所以需要定义要操作的表的model，在go中需要定义一个struct， struct的名字就是对应数据库中的表名，注意gorm查找struct名对应数据库中的表名的时候会默认把你的struct中的大写字母转换为小写并加上“s”，所以可以加上 db.SingularTable(true) 让grom转义struct名字的时候不用加上s。我是提前在数据库中创建好表的然后再用grom去查询的，也可以用gorm去创建表，我感觉还是直接在数据库上创建，修改表字段的操作方便，grom只用来查询和更新数据。

假设数据库中的表已经创建好，下面是数据库中的建表语句：

CREATE TABLE `xz_auto_server_conf` (
 `id` int(11) NOT NULL AUTO_INCREMENT,
 `group_zone` varchar(32) NOT NULL COMMENT ''大区例如：wanba,changan,aiweiyou,360'',
 `server_id` int(11) DEFAULT ''0'' COMMENT ''区服id'',
 `server_name` varchar(255) NOT NULL COMMENT ''区服名称'',
 `open_time` varchar(64) DEFAULT NULL COMMENT ''开服时间'',
 `service` varchar(30) DEFAULT NULL COMMENT ''环境，test测试服，formal混服，wb玩吧'',
 `username` varchar(100) DEFAULT NULL COMMENT ''data管理员名称'',
 `submit_date` datetime DEFAULT NULL COMMENT ''记录提交时间'',
 `status` tinyint(2) DEFAULT ''0'' COMMENT ''状态，0未处理，1已处理，默认为0'',
 PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

定义model，即struct, 定于struct时我们可以只定义我们需要从数据库中取回的特定字段：

gorm在转义表名的时候会把stuct的大写字母(首字母除外) 替换成“_”，所以下面的"XzAutoServerConf "会转义成数数据库中对应“xz_auto_server conf”的表名, 对应的字段名的查找会先按照tag里面的名称去里面查找，如果没有定义标签则按照struct定义的字段查找，查找的时候struct字段中的大写会被转义成“ ”,例“GroupZone”会去查找表中的group_zone字段

//定义struct
type XzAutoServerConf struct {
 GroupZone string `gorm:"column:group_zone"`
 ServerId int
 OpenTime string
 ServerName string
 Status int
}
//定义数据库连接
type ConnInfo struct {
 MyUser string
 Password string
 Host string
 Port int
 Db string
}

func main () {
cn := ConnInfo{
  "root",
  123456",
  "127.0.0.1",
  3306,
  "xd_data",
 }
  db := DbConn(cn.MyUser,cn.Password,cn.Host,cn.Db,cn.Port)
  defer db.Close() // 关闭数据库链接，defer会在函数结束时关闭数据库连接
 var rows []api.XzAutoServerConf
//select 
db.Where("status=?", 0).Select([]string{"group_zone", "server_id", "open_time", "server_name"}).Find(&rows)
//update
 err := db.Model(&rows).Where("server_id=?", 80).Update("status", 1).Error
 if err !=nil {
 fmt.Println(err)
 }
fmt.Println(rows)
}

更多grom操作可以参考： https://jasperxu.github.io/gorm-zh/

下面看下Golang GORM使用

gorm

gorm是go语言中实现数据库访问的ORM（对象关系映射）库。使用这个库，我们可以利用面向对象的方法，更加方便的对数据库中的数据进行CRUD(增删改查)。

基本使用

下载依赖

go get github.com/jinzhu/gorm
go get github.com/go-sql-driver/mysql

第一个是核心库。
第二个是mysql驱动包。

连接数据库

packae main
import (
 "github.com/jinzhu/gorm"
 _ "github.com/jinzhu/gorm/dialects/mysql"
 "fmt"
)
func main() {
 db, err := gorm.Open("mysql",
 "root:root@/test?charset=utf8&parseTime=True&loc=Local")

 if err != nil {
  fmt.Println(err)
  return
 }else {
  fmt.Println("connection succedssed")
 }
 defer db.Close()

新增数据

type User struct {
 ID  int   `gorm:"primary_key"`
 Name string   `gorm:"not_null"`
}
func add() {
 user := &User{Name:"zhangsan"}
 db.Create(user)
}

删除数据

user := &User{ID:1}
db.delete(user)

更新数据

user := &User{ID:1}
db.Model(user).update("Name","lisi")

查询数据

// query all
var users []User
db.Find(&users)
fmt.Println(users)
// query one
user := new (User)
db.First(user,1)
fmt.Println(user)

其它

判断数据库中是否有结构体对应的表：

db.HasTable(User{})

创建表

db.CreateTable(User{})

以上就是gorm基本的用法。

总结

以上所述是小编给大家介绍的golang gorm 操作mysql及gorm基本用法，希望对大家有所帮助，如果大家有任何疑问请给我留言，小编会及时回复大家的。在此也非常感谢大家对网站的支持！

您可能感兴趣的文章:
  • golang gorm错误处理事务以及日志用法示例
  • golang gorm的Callbacks事务回滚对象操作示例
  • golang gorm的预加载及软删硬删的数据操作示例
  • golang gorm的关系关联实现示例
  • golang gorm模型结构体的定义示例
  • golang gorm框架数据库的连接操作示例
  • golang gorm开发架构及写插件示例

今天关于golang - gorm的介绍到此结束，谢谢您的阅读，有关GOLANG BEEGO ORM、Golang Gorm Fiber / argon2.Config 未定义、golang gorm 基本使用、golang gorm 操作mysql及gorm基本用法等更多相关知识的信息可以在本站进行查询。

本文标签：

上一篇springmvc - 关于Controller中方法参数类型的几点注意（spring mvc controller 参数）

下一篇Struts 2 学习笔记 (一) HelloWorld（struts2入门）

相关文章