Golang은 페이징을 구현합니다.

인터넷 기술이 발전하고 데이터 양이 증가함에 따라 데이터에 대한 페이징 쿼리가 점점 더 일반화되고 있습니다. golang에서는 페이징 쿼리가 그다지 번거롭지 않으며 일부 최적화를 통해 페이징 효율성을 향상시킬 수 있습니다.

1. 기본 페이징

golang에서 페이징 쿼리의 가장 기본적인 방법은 SQL 문에서 제한 절을 사용하는 것입니다. 예:

SELECT * FROM table LIMIT offset, limit;

여기서 offset은 오프셋을 나타내고 제한은 반환된 레코드 수를 나타냅니다. 예를 들어, 각 페이지에 10개의 데이터가 표시되면 1페이지의 sql 문은 다음과 같습니다.

SELECT * FROM table LIMIT 0, 10;

2페이지의 sql 문은 다음과 같습니다.

SELECT * FROM table LIMIT 10, 10;

이 방법을 사용하려면 오프셋과 레코드 수를 수동으로 계산해야 합니다. 각 페이지는 더 번거롭고 오류가 발생하기 쉽습니다. 따라서 일부 라이브러리를 사용하여 페이지 매김 쿼리 구현을 단순화할 수 있습니다.

2. gorm 라이브러리를 사용하여 페이징 구현

gorm은 일반적으로 사용되는 golang orm 라이브러리로 매우 편리한 페이징 쿼리 방법을 제공합니다. 내장된 Limit 및 Offset 메서드를 사용하여 페이징 쿼리를 구현할 수 있습니다. 예:

db.Limit(10).Offset(0).Find(&users)

그 중 Limit 메소드는 반환된 레코드 수를 나타내고, Offset 메소드는 오프셋을 나타내며, Find 메소드는 쿼리를 실행하는 데 사용됩니다.

다음은 gorm 라이브러리를 사용하여 페이징 쿼리를 구현하는 방법을 보여주는 간단한 예입니다.

package main

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

type User struct {
    Id   int
    Name string
    Age  int
}

func main() {
    db, _ := gorm.Open("mysql", "root:123456@/test?charset=utf8mb4&parseTime=True&loc=Local")

    defer db.Close()

    // 创建表
    db.AutoMigrate(&User{})

    // 添加测试数据
    for i := 0; i < 100; i++ {
        user := User{Id: i + 1, Name: fmt.Sprintf("user%d", i+1), Age: i%20 + 10}
        db.Create(&user)
    }

    // 分页查询
    page := 5       // 第5页
    pageSize := 10   // 每页10条记录
    offset := (page - 1) * pageSize // 计算偏移量
    var users []User

    // 查询第5页的记录
    db.Limit(pageSize).Offset(offset).Find(&users)

    // 输出结果
    for _, user := range users {
        fmt.Printf("ID: %d, Name: %s, Age: %d
", user.Id, user.Name, user.Age)
    }
}

위 코드를 실행하면 출력 결과는 다음과 같습니다.

ID: 41, Name: user41, Age: 10
ID: 42, Name: user42, Age: 11
ID: 43, Name: user43, Age: 12
ID: 44, Name: user44, Age: 13
ID: 45, Name: user45, Age: 14
ID: 46, Name: user46, Age: 15
ID: 47, Name: user47, Age: 16
ID: 48, Name: user48, Age: 17
ID: 49, Name: user49, Age: 18
ID: 50, Name: user50, Age: 19

3 페이징 라이브러리를 사용하여 페이징을 구현합니다.

또한 gorm의 내장 페이징 방법 사용 또한 일부 타사 페이징 라이브러리를 사용하여 페이징을 구현할 수도 있습니다. 예:

1. paginator

paginator는 mysql, postgres, sqlite3 및 기타 데이터베이스를 지원하는 경량 golang 페이징 라이브러리입니다. 사용이 매우 간단합니다. 현재 페이지 번호, 페이지당 레코드 수 및 총 레코드 수를 지정하기만 하면 됩니다. 다음은 예입니다.

package main

import (
    "fmt"
    "github.com/biezhi/gorm-paginator/pagination"
    _ "github.com/jinzhu/gorm/dialects/mysql"
    "github.com/jinzhu/gorm"
)

type User struct {
    Id   uint `gorm:"primary_key"`
    Name string
    Age  uint
}

func main() {
    db,_ := gorm.Open("mysql", "root:123456@/test?charset=utf8mb4&parseTime=True&loc=Local")

    var users []User
    pagination.Paging(&pagination.Param{
        DB:      db,
        Page:    5,
        Limit:   10,
        OrderBy: []string{"id desc"},
        ShowSQL: true,
    }, &users)

    for _, user := range users {
        fmt.Printf("ID: %d, Name: %s, Age: %d
", user.Id, user.Name, user.Age)
    }
}

2. go-paginator

go-paginator는 데이터베이스에 의존하지 않고 사용하기 매우 편리한 또 다른 경량 골랭 페이징 라이브러리입니다. 다음은 예입니다.

package main

import (
    "fmt"
    "github.com/liyuliang/go-paginator"
)

type User struct {
    Id   uint
    Name string
    Age  uint
}

func main() {
    var users []User
    pageSize := 10                                    // 每页记录数
    page, _ := paginator.New(paginator.Config{        // 初始化分页器
        CurrentPage: 5,                               // 当前页码
        PageSize:    pageSize,                         // 每页记录数
        Total:       100,                              // 总记录数
    })

    records := make([]interface{}, 100)                // 模拟100条记录
    for i := 0; i < 100; i++ {
        user := User{Id: uint(i + 1), Name: fmt.Sprintf("user%d", i+1), Age: uint(i%20 + 10)}
        records[i] = user
    }

    pageData := page.Data(records)                     // 获取分页数据
    offset := (page.CurrentPage - 1) * pageSize         // 计算偏移量
    users = pageData[offset : offset+pageSize].([]User) // 获取当前页的记录

    for _, user := range users {
        fmt.Printf("ID: %d, Name: %s, Age: %d
", user.Id, user.Name, user.Age)
    }
}

그러나 페이징 라이브러리에서는 일반적으로 총 레코드 수를 수동으로 계산해야 하므로 쿼리 효율성에 영향을 미칠 수 있습니다. 따라서 총 레코드 수가 그리 많지 않은 경우에는 페이징 라이브러리를 사용할 수 없고 gorm에 내장된 페이징 방법을 사용합니다.

4. 페이징 최적화

실제 애플리케이션에서 페이징 쿼리는 특히 데이터 양이 많을 때 성능 문제에 직면할 수 있습니다. 쿼리 효율성을 높이기 위해 다음과 같은 최적화 방법 중 일부를 채택할 수 있습니다.

1. 캐시 사용

데이터를 실시간으로 업데이트할 필요가 없는 경우 쿼리 결과를 메모리에 캐시할 수 있으며, 데이터베이스에 자주 액세스하는 것을 피하기 위해 다음에 액세스할 때 캐시에서 직접 데이터를 얻을 수 있습니다.

2. 반환되는 필드 수 줄이기

쿼리된 레코드에 많은 수의 필드가 포함되어 있는 경우 대량의 불필요한 데이터를 쿼리하는 것을 피하기 위해 일부 필드만 반환할 수 있습니다.

3. 색인 사용

자주 쿼리되는 필드에 인덱스를 추가하면 쿼리 효율성이 크게 향상될 수 있습니다.

4. 일괄 쿼리

데이터 양이 많은 경우 일괄 쿼리를 사용하면 한 번에 너무 많은 데이터를 쿼리하여 발생하는 비효율성을 방지하기 위해 일괄 쿼리를 사용하여 한 번에 여러 데이터를 쿼리할 수 있습니다.

일반적으로 golang에서 페이징 쿼리를 구현하는 것은 매우 간단합니다. 내장된 gorm 라이브러리와 타사 페이징 라이브러리를 통해 페이징 기능을 쉽게 구현할 수 있으며 일부 최적화를 통해 쿼리 효율성을 향상시킬 수 있습니다.

위 내용은 Golang은 페이징을 구현합니다.의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!