Comment implémenter la pagination des requêtes dans Golang

Le langage Go est l'un des langages de programmation les plus populaires ces dernières années. Avec ses avantages de haute efficacité et de forte évolutivité, il est largement utilisé par de plus en plus de développeurs dans divers domaines. Parmi eux, la fonction de pagination des requêtes de Golang est largement utilisée et constitue une exigence fonctionnelle courante dans de nombreuses applications au niveau de l'entreprise. Cet article présentera en détail les méthodes d'implémentation et des exemples de pagination de requêtes Golang.

1. Méthode de mise en œuvre de la pagination des requêtes Golang

1. Adopter le framework ORM

ORM (Object-Relation Mapping) est une technologie de programmation qui mappe des objets et des bases de données relationnelles, et c'est aussi une idée de programmation. Le framework ORM est une technologie relativement mature.Par exemple, GORM dans golang est un framework ORM open source qui peut mapper des structures et des tables de base de données et convertir les opérations CRUD en instructions de requête de base de données, permettant ainsi le stockage et la lecture des données.

GORM est l'un des frameworks ORM les plus populaires de Golang. Il fournit des opérations API très simples, même les débutants peuvent facilement démarrer. En utilisant GORM, nous pouvons facilement implémenter des requêtes de pagination basées sur SQL. Le code d'implémentation spécifique est le suivant :

func FindPage(pageNum int, pageSize int) (users []User, total int64, err error) {
    tx := db.Model(&User{})
    tx.Count(&total)
    err = tx.Offset((pageNum - 1)*pageSize).Limit(pageSize).Find(&users).Error
    if err != nil && err != gorm.ErrRecordNotFound {
        return nil, 0, err
    }
    return
}

Dans le code ci-dessus, nous définissons une fonction nommée FindPage pour implémenter les requêtes de pagination. Tout d’abord, nous obtenons le modèle User via la méthode db.Model(), puis appelons la méthode Count() pour compter le nombre total d’enregistrements interrogés, puis utilisons les méthodes Offset et Limit pour implémenter la pagination, et enfin appelons Find( ; ) méthode pour stocker les résultats de la requête dans la variable utilisateurs. De plus, lors du processus de requête, une attention particulière doit être accordée à la gestion des erreurs afin de garantir la sécurité et la fiabilité des appels de fonction.

2. Fonction de requête de pagination personnalisée

Dans les applications réelles, vous pouvez également définir votre propre fonction de requête de pagination pour mieux répondre aux besoins de votre entreprise. La méthode d'implémentation spécifique est la suivante :

func CustomFindPage(pageNum int, pageSize int, query string) (users []User, total int64, err error) {
    sql := "SELECT * FROM users WHERE 1 = 1 " + query + " ORDER BY created_at DESC LIMIT ? OFFSET ?"
    err = db.Raw(sql, pageSize, (pageNum-1)*pageSize).Scan(&users).Error
    if err != nil && err != gorm.ErrRecordNotFound {
        return nil, 0, err
    }
    err = db.Model(&User{}).Where(query).Count(&total).Error
    if err != nil {
        return nil, 0, err
    }
    return
}

Différente du framework ORM, cette méthode utilise des instructions SQL natives pour l'implémentation, et les conditions de requête et les instructions de requête peuvent être librement définies pour mieux répondre aux besoins de l'entreprise.

2. Exemples de pagination de requêtes Golang

1. Le framework ORM implémente la requête de pagination

Référez-vous au code suivant :

type User struct {
    gorm.Model
    Name string `gorm:"column:name" json:"name"`
    Age  int    `gorm:"column:age" json:"age"`
}

func main() {
    db, err := gorm.Open("mysql", "user:password@tcp(127.0.0.1:3306)/demo_golang?charset=utf8mb4&parseTime=True&loc=Local")
    if err != nil {
        panic(err)
    }
    defer db.Close()

    var (
        pageNum  = 1
        pageSize = 10
        users    []User
        total    int64
    )
    if users, total, err = FindPage(pageNum, pageSize); err != nil {
        fmt.Printf("查询用户列表失败：%v\n", err)
        return
    }
    fmt.Printf("查询到的用户列表如下：\n%+v\n总记录数：%d\n", users, total)
}

Le code ci-dessus implémente la fonction de requête de pagination basée sur le framework ORM. Parmi eux, vous devez d'abord définir le modèle utilisateur et construire la base de données via GORM. Ensuite, définissez une fonction de requête nommée FindPage(), qui contient deux paramètres, pageNum et pageSize, pour interroger les données du numéro de page spécifié et le nombre d'enregistrements affichés sur chaque page. La fonction renvoie deux valeurs, l'une est la liste des utilisateurs interrogés et l'autre est le nombre total d'enregistrements dans la liste. Enfin, appelez la fonction FindPage() dans la fonction principale pour interroger et afficher les résultats de la requête de pagination.

2. Fonction personnalisée pour implémenter la requête de pagination

Référez-vous au code suivant :

type User struct {
    Name      string `gorm:"column:name" json:"name"`
    Age       int    `gorm:"column:age" json:"age"`
    CreatedAt int64  `gorm:"column:created_at" json:"created_at"`
}

func main() {
    db, err := gorm.Open("mysql", "user:password@tcp(127.0.0.1:3306)/demo_golang?charset=utf8mb4&parseTime=True&loc=Local")
    if err != nil {
        panic(err)
    }
    defer db.Close()

    var (
        pageNum  = 1
        pageSize = 10
        order    = "DESC"
        field    = "created_at"
        query    = ""
        users    []User
        total    int64
    )
    if users, total, err = CustomFindPage(pageNum, pageSize, query, field, order); err != nil {
        fmt.Printf("查询用户列表失败：%v\n", err)
        return
    }
    fmt.Printf("查询到的用户列表如下：\n%+v\n总记录数：%d\n", users, total)
}

Le code ci-dessus implémente la fonction de pagination de requête basée sur la fonction de requête de pagination personnalisée. Parmi eux, vous devez d'abord définir le modèle User, définir les paramètres de requête (pageNum, pageSize, field, order, query) dans la fonction principale, puis appeler la fonction CustomFindPage() pour implémenter la requête de pagination. Il convient de noter que dans la fonction de requête personnalisée, vous devez séparer manuellement l'instruction SQL et les conditions de requête, et utiliser l'instruction SQL native pour interroger. De plus, nous pouvons modifier davantage la fonction de requête de pagination personnalisée en fonction de besoins spécifiques pour obtenir des requêtes plus flexibles.

3. Résumé

Cet article présente les méthodes d'implémentation et des exemples de pagination de requêtes Golang, de l'utilisation de base du framework ORM aux fonctions de requête de pagination personnalisées, couvrant les méthodes de requête courantes dans les applications pratiques. Que vous soyez un développeur Golang débutant ou expérimenté, vous pouvez apprendre les méthodes de mise en œuvre spécifiques et mieux comprendre les fonctionnalités et technologies du langage Golang.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!