Nouvel ORM PostgreSQL pour Golang : Entreprise

Pourquoi avons-nous besoin d'un nouvel ORM ?

Il existe en fait quelques bons ORM disponibles, mais ils ne répondent tout simplement pas à mes besoins. Alors qu'est-ce que je voulais ?

• Hautes performances
• Schéma sous forme de code
• Code API saisi et généré statiquement
• Moins de fichier généré
• Simple et fonctionnel
• Utilisation facile de RawSQL
• Filtre d'accès à une seule base de données lors de la jointure d'une relation

Pour le moment, je ne peux pas dire que les entreprises réussissent bien toutes les choses que j'ai mentionnées. Mais il vise à le faire.

Regardons donc ce que font les entreprises.

Hautes performances

Vous pouvez voir le code source de référence ici.
https://github.com/MrSametBurgazoglu/go-orm-benchmarks/tree/enterprise

Comme vous pouvez le constater, l'entreprise est très performante.

Schéma en tant que code

Comme beaucoup d'autres entreprises, génèrez des modèles de base de données à partir de votre code.
Voici un petit exemple

// db_models/account.go
package db_models

import (
    "github.com/MrSametBurgazoglu/enterprise/models"
    "github.com/google/uuid"
)

func Account() *models.Table {
    idField := models.UUIDField("ID").DefaultFunc(uuid.New)

    tb := &models.Table{
        Fields: []models.FieldI{
            idField,
            models.StringField("Name"),
            models.StringField("Surname"),
            models.UUIDField("TestID").SetNillable(),
        },
        Relations: []*models.Relation{
            models.ManyToOne(TestName, idField.DBName, "test_id"),
            models.ManyToMany(GroupName, "account_id", "group_id", "id", AccountGroupName),
        },
    }

    tb.SetTableName(AccountName)
    tb.SetIDField(idField)

    return tb
}

// generate/generate.go
package main

import (
    "example/db_models"
    "github.com/MrSametBurgazoglu/enterprise/generate"
)

func main() {
    generate.Models(
        db_models.Test(),
        db_models.Account(),
        db_models.Group(),
    )
}

Lorsque vous exécutez le script ci-dessus, il créera un package nommé models et placera deux fichiers pour chaque table nommés model.go et model_predicates.go . Et il y aura un client.go pour utiliser db.

Code API saisi et généré statiquement

Après la génération automatique des modèles, vous pouvez créer et obtenir des modèles.

import "/your/project/models" // your auto-generated models package

func main() {
    db, err := models.NewDB(dbUrl)
    if err != nil {
        panic(err)
    }

    ctx := context.Background()
    account := models.NewAccount(ctx, db)
    account.SetName("name")
    account.SetSurname("surname")
    err = account.Create()//row added to table
    if err != nil {
        log.Fatal(err)
    }
}

import "/your/project/models" // your auto-generated models package

func main() {
    db, err := models.NewDB(dbUrl)
    if err != nil {
        panic(err)
    }

    ctx := context.Background()
    account := models.NewAccount(ctx, db)
    account.Where(account.IsIDEqual(uuid.New()))
    err = account.Get()//row variables set to account struct
    if err != nil {
        log.Fatal(err)
    }
}

Moins de fichier généré

Comme je l'ai dit avant, l'entreprise génère 2 fichiers pour chaque table et un fichier client qui les utilise tous. Il gère la plupart des cas dans son propre package, de cette façon vous aurez une structure plus propre.

Simple et fonctionnel

Enterprise vise une interaction simple et fonctionnelle avec les champs de base de données. Pour cela, les champs ont des fonctions d'assistance.

Disons que vous avez un uuid nillable nommé face_id sur la table et que vous le représentez avec *uuid. Enterprise générera une fonction d'assistance pour le définir avec une chaîne. De cette façon, vous n'avez pas besoin d'obtenir le pointeur de cette variable.

func (t *Account) SetFaceIDValue(v uuid.UUID)

Si vous avez un champ uuid, cela créera un assistant d'analyseur.

func (t *Account) ParseFaceID(v string) error

Pour certains types de valeur, il aura une clause IN.

func (t *Account) FaceIDIN(v ...uuid.UUID) bool
func (t *Account) FaceIDNotIN(v ...uuid.UUID) bool

Pour time.Time, il créera ces fonctions d'assistance.

func (t *Account) FormatCreatedAt(v string) string
func (t *Account) ParseCreatedAt(layout, value string) error

Utilisation facile de RawSQL

L'entreprise peut créer des requêtes complexes, mais le besoin de RawSQL le sera toujours. Pour cette raison, vous pouvez utiliser models.IDatabase pour interagir avec pgx. Nous prévoyons d'analyser le résultat SQL brut vers vos modèles de base de données ou les structures personnalisées que vous créez avec la relation si nécessaire.

Filtre d'accès à une seule base de données lors de la jointure d'une relation

L'une des fonctionnalités les plus importantes qui distingue Enterprise des autres est la possibilité de joindre des relations et de les filtrer avec une seule requête.

Un exemple est comme ceci. Obtenons les mauvaises réponses aux questions de test d'un élève dont le score est supérieur à 80.

// db_models/account.go
package db_models

import (
    "github.com/MrSametBurgazoglu/enterprise/models"
    "github.com/google/uuid"
)

func Account() *models.Table {
    idField := models.UUIDField("ID").DefaultFunc(uuid.New)

    tb := &models.Table{
        Fields: []models.FieldI{
            idField,
            models.StringField("Name"),
            models.StringField("Surname"),
            models.UUIDField("TestID").SetNillable(),
        },
        Relations: []*models.Relation{
            models.ManyToOne(TestName, idField.DBName, "test_id"),
            models.ManyToMany(GroupName, "account_id", "group_id", "id", AccountGroupName),
        },
    }

    tb.SetTableName(AccountName)
    tb.SetIDField(idField)

    return tb
}

Pour le référentiel : https://github.com/MrSametBurgazoglu/enterprise
Pour la documentation : https://mrsametburgazoglu.github.io/enterprise_docs/

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!