Neues PostgreSQL ORM für Golang: Enterprise

Warum brauchen wir ein neues ORM?

Es gibt tatsächlich ein paar gute ORMs, aber sie haben meine Bedürfnisse einfach nicht erfüllt. Was wollte ich also?

• Hohe Leistung
• Schema als Code
• Statisch typisierter und generierter API-Code
• Weniger generierte Datei
• Einfach und funktional
• Einfache RawSQL-Nutzung
• Einzelner DB-Trefferfilter bei Join-Beziehung

Im Moment kann ich nicht sagen, dass Unternehmen alle von mir genannten Dinge gut machen. Aber das Ziel ist es.

Schauen wir uns also an, was Unternehmen tun.

Hohe Leistung

Den Benchmark-Quellcode können Sie hier sehen.
https://github.com/MrSametBurgazoglu/go-orm-benchmarks/tree/enterprise

Wie Sie sehen, ist die Leistung des Unternehmens sehr gut.

Schema als Code

Generieren Sie wie viele andere Unternehmen Datenbankmodelle aus Ihrem Code.
Hier ist ein kleines Beispiel

// 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(),
    )
}

Wenn Sie das obige Skript ausführen, wird ein Paket mit dem Namen „models“ erstellt und zwei Dateien für jede Tabelle mit den Namen „model.go“ und „model_predicates.go“ abgelegt. Und es wird ein client.go für die Verwendung von db geben.

Statisch typisierter und generierter API-Code

Nach der automatischen Generierung von Modellen können Sie Modelle erstellen und abrufen.

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

Weniger generierte Datei

Wie ich bereits sagte, generiert das Unternehmen zwei Dateien für jede Tabelle und eine Client-Datei, die alle verwendet. Die meisten Fälle werden in einem eigenen Paket behandelt, sodass Sie eine sauberere Struktur erhalten.

Einfach und funktional

Enterprise strebt eine einfache und funktionale Interaktion mit Datenbankfeldern an. Dafür verfügen Felder über Hilfsfunktionen.

Angenommen, Sie haben eine nillierbare UUID mit dem Namen face_id in der Tabelle und stellen sie mit *uuid dar. Enterprise generiert eine Hilfsfunktion, um es mit einer Zeichenfolge festzulegen. Auf diese Weise müssen Sie keinen Zeiger auf diese Variable abrufen.

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

Wenn Sie ein UUID-Feld haben, wird ein Parser-Helfer erstellt.

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

Für einige Werttypen wird es eine IN-Klausel geben.

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

Für time.Time werden diese Hilfsfunktionen erstellt.

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

Einfache RawSQL-Nutzung

Unternehmen können komplexe Abfragen erstellen, RawSQL wird jedoch immer benötigt. Aus diesem Grund können Sie models.IDatabase verwenden, um mit pgx zu interagieren. Wir planen, bei Bedarf rohe SQL-Ergebnisse in Ihre Datenbankmodelle oder benutzerdefinierten Strukturen, die Sie mit Relation erstellen, einzuscannen.

Einzeldatenbank-Trefferfilter bei Verknüpfungsbeziehung

Eine der wichtigsten Funktionen, die Enterprise von anderen unterscheidet, ist die Möglichkeit, Beziehungen zu verbinden und sie mit einer einzigen Abfrage zu filtern.

Ein Beispiel ist so. Lassen Sie uns die Testfragen eines Schülers falsch beantworten, wenn die Testpunktzahl höher als 80 ist.

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

Für das Repository: https://github.com/MrSametBurgazoglu/enterprise
Zur Dokumentation: https://mrsametburgazoglu.github.io/enterprise_docs/

Das obige ist der detaillierte Inhalt vonNeues PostgreSQL ORM für Golang: Enterprise. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!