GORM

ORM

What is ORM?

Object Relational Mapping

Object relational mapping

Object: instances of structures in Go, classes in Java

Relational: Relational databases, such as mysql

ORM the pros and cons

Advantages:

Improve development efficiency

Disadvantages:

1. Sacrificing execution performance
2. Sacrifice flexibility
3. Weakening SQL Performance

GORM is quick to get started

Install GORM:

go get -u github.com/jinzhu/gorm
Copy the code

Connecting to a Database

Connect different databases need to import the corresponding data driver, GORM has been intimate for us to package some drivers, just need to import the need for the database driver as follows:

import _ "github.com/jinzhu/gorm/dialects/mysql"
// import _ "github.com/jinzhu/gorm/dialects/postgres"
// import _ "github.com/jinzhu/gorm/dialects/sqlite"
// import _ "github.com/jinzhu/gorm/dialects/mssql"
Copy the code

Connect the MySQL

import (
  "github.com/jinzhu/gorm"
  _ "github.com/jinzhu/gorm/dialects/mysql"
)
​
func main() {
  db, err := gorm.Open("mysql", "user:password@(localhost)/dbname?charset=utf8mb4&parseTime=True&loc=Local")
  defer db.Close()
}
Copy the code

Connect the PostgreSQL

The basic code is the same as above, noting that the corresponding postgres driver is introduced and the gorm.open () argument is specified correctly.

import (
  "github.com/jinzhu/gorm"
  _ "github.com/jinzhu/gorm/dialects/postgres"
)
​
func main() {
  db, err := gorm.Open("postgres", "host=myhost port=myport user=gorm dbname=gorm password=mypassword")
  defer db.Close()
}
Copy the code

Connect the Sqlite3

The basic code is the same as above, note that the corresponding SQLite driver is introduced and the gorm.open () parameter is specified correctly.

import (
  "github.com/jinzhu/gorm"
  _ "github.com/jinzhu/gorm/dialects/sqlite"
)
​
func main() {
  db, err := gorm.Open("sqlite3", "/tmp/gorm.db")
  defer db.Close()
}
Copy the code

Connect the SQL Server

The basic code is the same as above, note that the corresponding MSSQL driver is introduced and the gorm.open () parameter is specified correctly.

import (
  "github.com/jinzhu/gorm"
  _ "github.com/jinzhu/gorm/dialects/mssql"
)
​
func main() {
  db, err := gorm.Open("mssql", "sqlserver://username:password@localhost:1433?database=dbname")
  defer db.Close()
}
Copy the code

GORM operates on MySql instances

Package the main import (" FMT "" github.com/jinzhu/gorm" _ "github.com/jinzhu/gorm/dialects/mysql") / / the UserInfo = > data table type UserInfo struct {ID uint Name string Gender string Hobby string} func main() { Err := gorm.Open("mysql","root:mysql@tcp(127.0.0.1:3306)/user? Charset = UTf8MB4&parseTime =True&loc=Local") if err! Db.automigrate (&userInfo {}) db.automigrate (&userInfo {}) // Create row U1 := UserInfo{ID: 1, Name: "Mike", Gender: "male ", Hobby: "Running", Db.model (&u1).Update("hobby"," swim "); var u = new (UserInfo) db.first (u); FMT.Println(u) // Delete db.delete (&u1)}Copy the code

GORM MODEL definition

When using ORM tools, we usually need to define Models in code to map data tables in a database. In GORM, Models are usually normally defined constructs, basic GO types, or Pointers to them. Sql. Scanner and driver.Valuer interfaces are also supported.

gorm.Model

To facilitate Model definition, GORM has a built-in gorm.model structure. Gorm.Model is a Golang structure containing four fields: ID, CreatedAt, UpdatedAt, and DeletedAt.

// gorm.Model Definition Type Model struct {ID uint 'gorm:"primary_key"' CreatedAt time. time UpdatedAt time. time DeletedAt *time.Time }Copy the code

You can embed it in your own model:

Type User struct {gorm.Model Name string} struct {gorm.Copy the code

Of course, you can completely define the model yourself:

Type User struct {ID int Name string}Copy the code

Example model definition

Type User struct {gorm.Model // nested gorm.Model Name string Age SQL.NullInt64 Birthday *time `gorm:"type:varchar(100); Unique_index "' Role string 'gorm:"size:255"' // Set the field size to 255 MemberNumber *string 'gorm:"unique; Num int 'GORm :"AUTO_INCREMENT"' // Set Num to AUTO_INCREMENT type Address string IgnoreMe int 'gorm:"-"' // Ignore this field}Copy the code

Structure markup (tags)

Tags are optional when using structures to declare models. Gorm supports the following tags:

Supported structure tags (Struct tags)

Associate related tags (tags)

Conventions for primary keys, table names, and column names

Primary Key

By default, GORM uses a field named ID as the primary key of the table.

Animal struct {AnimalID int64} type Animal struct {AnimalID int64  `gorm:"primary_key"` Name string Age int64 }Copy the code

Table Name

The default table name is the plural of the structure name, for example:

Type User struct {} // default TableName is' users' // set User TableName to 'profiles' func (User) TableName() string {return "profiles"} func (u User) TableName() string { if u.Role == "admin" { return "admin_users" } else { return "users" } } // Disable the plural form of the default table name. If true, the default table name of 'User' is' User 'db.singularTable (true).Copy the code

You can also specify the Table name by using Table() :

Db.table ("deleted_users").createTable (&user {}) var deleted_users []User db.Table("deleted_users").Find(&deleted_users) //// SELECT * FROM deleted_users; db.Table("deleted_users").Where("name = ?" , "jinzhu").Delete() //// DELETE FROM deleted_users WHERE name = 'jinzhu';Copy the code

GORM also supports changing the default table name rule:

gorm.DefaultTableNameHandler = func (db *gorm.DB, defaultTableName string) string  {
  return "prefix_" + defaultTableName;
}
Copy the code

Column Name

Column names are generated by underlining the field names

type User struct { ID uint // column name is `id` Name string // column name is `name` Birthday time.Time // column name  is `birthday` CreatedAt time.Time // column name is `created_at` }Copy the code

Column names can be specified using the structure tag:

type Animal struct {
  AnimalId    int64     `gorm:"column:beast_id"`         // set column name to `beast_id`
  Birthday    time.Time `gorm:"column:day_of_the_beast"` // set column name to `day_of_the_beast`
  Age         int64     `gorm:"column:age_of_the_beast"` // set column name to `age_of_the_beast`
}
Copy the code

Timestamp tracking

CreatedAt

If the model has a CreatedAt field, the value of that field will be when the record was first created.

Db.create (&user) // 'CreatedAt' will be the current time // The 'Update' method can be used to change the value of 'CreateAt' db.model (&user).update ("CreatedAt", time.now ())Copy the code

UpdatedAt

If the model has an UpdatedAt field, the value of that field will be the time each record is updated.

Db.save (&user) // 'UpdatedAt' will be the current time db.model (&user).Update("name", "Jinzhu ") // 'UpdatedAt' will be the current timeCopy the code

DeletedAt

If the model has a DeletedAt field, calling Delete to Delete the record sets the DeletedAt field to the current time rather than directly deleting the record from the database.