11-grom-v2-04-advanced query

1. use Struct or Map receive data

1.1 Find To Struct

Define a small structure to receive the query results in the table

db.Model(User{
    }).Find(&UserModels)

• Complete example
  Existing data sheet

mysql> select * from users;
+----+----------+------+--------------------+
| id | name     | age  | email              |
+----+----------+------+--------------------+
|  1 | LiuBei   |   28 | [e-mail]   |
|  2 | GuanYu   |   22 | [e-mail]   |
|  3 | ZhangFei |   20 | [e-mail] |
+----+----------+------+--------------------+
3 rows in set (0.00 sec)

Code

package main

import (
	"database/sql"
	"fmt"
	"gorm.io/driver/mysql"
	"gorm.io/gorm"
	"time"
)

type User struct {
    
	ID int64
	Age int64
	Name string
	Email string
}

type userModel struct {
    
	ID int64
	Name string
}

func main() {
    
	db,sqlDB,_ := connect()
	defer sqlDB.Close()

    var UserModels  []userModel
	db.Model(User{
    }).Find(&UserModels)
	fmt.Println(UserModels)
}

func connect() (db *gorm.DB,sqlDB *sql.DB,err error) {
    
	dsn := "root:[email protected](127.0.0.1:3306)/crow?charset=utf8&parseTime=True&loc=Local"
	db, err = gorm.Open(mysql.Open(dsn), &gorm.Config{
    })
	sqlDB,_ = db.DB()
	if err != nil {
    
		fmt.Printf(err.Error())
		defer sqlDB.Close()
	}else {
    
		fmt.Printf("OK\n")
		sqlDB.SetMaxIdleConns(10)
		sqlDB.SetMaxOpenConns(100)
		sqlDB.SetConnMaxLifetime(time.Hour)
	}
	return
}

Results output

OK
[{
    1 LiuBei} {
    2 GuanYu} {
    3 ZhangFei}]

1.2 Find To Map

Define a Map To receive data

func main() {
    
	db,sqlDB,_ := connect()
	defer sqlDB.Close()
	
	var users  map[string]interface{
    }
	db.Table("users").Find(&users)
	fmt.Println(users)
}

2. Subquery

db.Where("age > (?)", db.Table("users").Select("AVG(age)")).Find(&users)
// SELECT * FROM "users" WHERE age > (SELECT AVG(age) FROM "users");

• Example

func main() {
    
	db,sqlDB,_ := connect()
	defer sqlDB.Close()

    var users []User
	db.Where("age > (?)", db.Table("users").Select("AVG(age)")).Find(&users)
	fmt.Println(users)
}

• Query results

OK
[{
    1 28 LiuBei [email protected]}]

3. Group/Having

3.1 Group

Sum up 、 Grouping of average value, etc

db.Table("users").Select("AVG(age) as avg_age","company").Group("company").Find(&users)

Complete example

Find the average age of each company in the table below

• Data sheet

mysql> select * from users;
+----+----------+------+--------------------+---------+
| id | name     | age  | email              | company |
+----+----------+------+--------------------+---------+
|  1 | LiuBei   |   28 | [e-mail]   | shu     |
|  2 | GuanYu   |   22 | [e-mail]   | shu     |
|  3 | ZhangFei |   20 | [e-mail] | shu     |
|  4 | SunQuan  |   22 | [e-mail] | wu      |
|  5 | ZhouYu   |   15 | [e-mail]  | wu      |
+----+----------+------+--------------------+---------+
5 rows in set (0.00 sec)

• Code

package main

import (
	"database/sql"
	"fmt"
	"gorm.io/driver/mysql"
	"gorm.io/gorm"
	"time"
)

type User struct {
    
	ID int64
	Age int64
	Name string
	Email string
	Company string
}

type groupBy struct {
    
	AvgAge float64
	Company string

}


func main() {
    
	db,sqlDB,_ := connect()
	defer sqlDB.Close()

    var users []groupBy

	db.Table("users").Select("AVG(age) as avg_age","company").Group("company").Find(&users)
	fmt.Println(users)
}

func connect() (db *gorm.DB,sqlDB *sql.DB,err error) {
    
	dsn := "root:[email protected](127.0.0.1:3306)/crow?charset=utf8&parseTime=True&loc=Local"
	db, err = gorm.Open(mysql.Open(dsn), &gorm.Config{
    })
	sqlDB,_ = db.DB()
	if err != nil {
    
		fmt.Printf(err.Error())
		defer sqlDB.Close()
	}else {
    
		fmt.Printf("OK\n")
		sqlDB.SetMaxIdleConns(10)
		sqlDB.SetMaxOpenConns(100)
		sqlDB.SetConnMaxLifetime(time.Hour)
	}
	return
}

• Output results

OK
[{
    23.3333 shu} {
    18.5 wu}]

3.2 Having

Yes Group Filter the results of . The result obtained in the above example , use Having The average value obtained is greater than 20 Result .

db.Table("users").Select("AVG(age) as avg_age","company").Group("company").Having("avg_age > ?",20).Find(&users)

4. Variable

4.1 Use sql.Named Definition

db.Where("age > @age AND company = @company", sql.Named("company", "shu"),sql.Named("age", 20)).Find(&users)

4.2 Use map Defining variables

db.Where("age > @age AND company = @company",map[string]interface{
    }{
    "company": "shu","age":20}).First(&users)

• Example

func main() {
    
	db,sqlDB,_ := connect()
	defer sqlDB.Close()

    var users []User

	checkUser := map[string]interface{
    }{
    
		"company":"shu",
		"age":20,
	}

	db.Where("age > @age AND company = @company",checkUser).First(&users)
	fmt.Println(users)
}

5. use Rows() iteration

• Use
  use Rows() Record data ----> rows.Next() Read line by line -----> use ScanRows Assign to structure

• Example

func main() {
    
	db,sqlDB,_ := connect()
	defer sqlDB.Close()

	rows, _ := db.Model(&User{
    }).Where("company = ?", "shu").Rows()
	defer rows.Close()

	for rows.Next() {
    
		var user User
		// ScanRows  Method is used to scan a line of records to the structure 
		db.ScanRows(rows, &user)
		fmt.Println(user)
	}
}

6. Check hook

Write a query hook , When the query result field Company It's empty time , Replace with " Group "

func (u *User) AfterFind(tx *gorm.DB) (err error) {
    
	if u.Company == "" {
    
		u.Company = "qun"
	}
	return
}

7. Pluck（ Single column query ）

• effect
  Query single column data , And receive with a slice
• Examples

db.Model(&User{
    }).Pluck("name", &names)

• Code

func main() {
    
	db,sqlDB,_ := connect()
	defer sqlDB.Close()
	
	var names []string
	db.Model(&User{
    }).Pluck("name", &names)
	fmt.Println(names)
}

• Output

[LiuBei GuanYu ZhangFei YuJi ZhaoYun]

8. Scopes（ Call the query function ）

8.1 Use

• effect
  We can use Scopes Call the pre created function .
• Examples

db.Scopes( function 1, function 2).Find(&users)

8.2 Example

• Create a function

Create a function to query the age of about 20 Year old user data

func ageGT20db (db *gorm.DB) *gorm.DB {
    
	return db.Where("age > ?",20)
}

• Call function

func main() {
    
	db,sqlDB,_ := connect()
	defer sqlDB.Close()

	var users []User

	db.Scopes(ageGT20db).Find(&users)
	fmt.Println(users)
}

9. Count

• effect
  Count the number of data found

• Code

func main() {
    
	db,sqlDB,_ := connect()
	defer sqlDB.Close()

    var count int64
	var users []User

	db.Find(&users).Count(&count)
	fmt.Println(count)
}