Golang implementiert Paging

Mit der Entwicklung der Internettechnologie und der zunehmenden Datenmenge werden Paging-Abfragen nach Daten immer häufiger. In Golang ist die Paging-Abfrage nicht allzu problematisch, und die Paging-Effizienz kann durch einige Optimierungen verbessert werden.

1. Grundlegendes Paging

In Golang besteht die grundlegendste Art der Paging-Abfrage darin, die Limit-Klausel in der SQL-Anweisung zu verwenden. Beispiel:

SELECT * FROM table LIMIT offset, limit;

Wobei Offset den Offset und Limit die Anzahl der zurückgegebenen Datensätze darstellt. Wenn beispielsweise 10 Daten auf jeder Seite angezeigt werden, lautet die SQL-Anweisung auf Seite 1:

SELECT * FROM table LIMIT 0, 10;

Die SQL-Anweisung auf Seite 2 lautet:

SELECT * FROM table LIMIT 10, 10;

Dies Die Methode erfordert eine manuelle Berechnung jedes Seitenversatzes und der Datensatznummer, was relativ umständlich und fehleranfällig ist. Daher können wir einige Bibliotheken verwenden, um die Implementierung paginierter Abfragen zu vereinfachen.

2. Verwenden Sie die Gorm-Bibliothek zum Implementieren von Paging.

gorm ist eine häufig verwendete Golang-Orm-Bibliothek, die eine sehr praktische Paging-Abfragemethode bietet. Wir können die integrierten Methoden Limit und Offset verwenden, um Paging-Abfragen zu implementieren. Beispiel:

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

Unter diesen stellt die Limit-Methode die Anzahl der zurückgegebenen Datensätze dar, die Offset-Methode stellt den Offset dar und die Find-Methode wird zum Ausführen der Abfrage verwendet.

Das Folgende ist ein einfaches Beispiel, um zu demonstrieren, wie die Gorm-Bibliothek zum Implementieren einer Paging-Abfrage verwendet wird:

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)
    }
}

Führen Sie den obigen Code aus. Das Ausgabeergebnis lautet:

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. Verwenden Sie die Paging-Bibliothek, um Paging zu implementieren

Zusätzlich zur Verwendung der integrierten Paging-Methode von gorm können wir auch einige Paging-Bibliotheken von Drittanbietern verwenden, um Paging zu implementieren. Zum Beispiel:

paginator

paginator ist eine leichte Golang-Paging-Bibliothek, die MySQL, Postgres, SQLite3 und andere Datenbanken unterstützt. Die Verwendung ist sehr einfach. Geben Sie einfach die aktuelle Seitenzahl, die Anzahl der Datensätze pro Seite und die Gesamtzahl der Datensätze an. Das Folgende ist ein Beispiel:

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)
    }
}

go-paginator

go-paginator ist eine weitere leichte Golang-Paging-Bibliothek, die nicht auf einer Datenbank basiert ist sehr einfach zu bedienen. Das Folgende ist ein Beispiel:

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)
    }
}

Es ist jedoch zu beachten, dass Paging-Bibliotheken normalerweise eine manuelle Berechnung der Gesamtzahl der Datensätze erfordern, was sich auf die Abfrageeffizienz auswirken kann. Wenn die Gesamtzahl der Datensätze nicht sehr groß ist, können wir daher nicht die Paging-Bibliothek verwenden, sondern die integrierte Paging-Methode von Gorm verwenden.

4. Paging-Optimierung

In tatsächlichen Anwendungen können bei Paging-Abfragen einige Leistungsprobleme auftreten, insbesondere wenn die Datenmenge groß ist. Um die Abfrageeffizienz zu verbessern, können einige der folgenden Optimierungsmethoden verwendet werden:

Cache verwenden

Wenn die Daten nicht benötigt werden In Echtzeit aktualisiert werden, können die Abfrageergebnisse im Speicher zwischengespeichert werden und die Daten beim nächsten Zugriff direkt aus dem Cache abgerufen werden, um häufigen Zugriff auf die Datenbank zu vermeiden.

Reduzieren Sie die Anzahl der zurückgegebenen Felder.

Wenn der abgefragte Datensatz eine große Anzahl von Feldern enthält, können Sie nur einige Felder zurückgeben, um unnötige Felder zu vermeiden Daten abfragen.

Indizes verwenden

Das Hinzufügen von Indizes zu häufig abgefragten Feldern kann die Abfrageeffizienz erheblich verbessern.

Batch-Abfrage

Wenn die Datenmenge groß ist, kann die Batch-Abfrage verwendet werden, um jedes Mal einen Datenstapel abzufragen, um Abfragen zu vermeiden Zu viele Daten auf einmal führen zu Ineffizienz.

Im Allgemeinen ist es sehr einfach, Paging-Abfragen in Golang zu implementieren. Durch die integrierte Gorm-Bibliothek und die Paging-Bibliothek von Drittanbietern können wir die Paging-Funktion problemlos implementieren und die Abfrageeffizienz verbessern einige Optimierungen.

Das obige ist der detaillierte Inhalt vonGolang implementiert Paging. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!