New PostgreSQL ORM for Golang: Enterprise

Why we need a new ORM?

There are actually a few good ORMs available, but they just didn't meet my needs. So what did I want?

• High performance
• Schema as code
• Statically typed and generated api code
• Less generated file
• Simple and Functional
• Easy RawSQL usage
• Single db hit filter when join relation

At the moment I can't say enterprise do well all of the things I mentioned. But it aims to do so.

So let's look what enterprise do.

High Performance

You can see the benchmark source code here.
https://github.com/MrSametBurgazoglu/go-orm-benchmarks/tree/enterprise

As you can see enterprise is very well at performance.

Schema as code

Like many others enterprise generate db models from your code.
Here is a little example

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

When you execute the script above it will create a package named models and put two file for each table named model.go and model_predicates.go . And there will be a client.go for using db.

Statically typed and generated api code

After auto-generate models you can create and get models.

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

Less generated file

Like I said before enterprise generate 2 file for each table and one client file who uses all of them. It handles most cases in own package this way you will have more clean structure.

Simple and Functional

Enterprise aims simple and fuctional interaction with db fields. For this, fields have helper functions.

Let's say you have a nillable uuid named face_id on table and you represent it with *uuid. Enterprise will generate a helper function to set it with string. That way you don't need to get pointer of that variable.

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

If you have a uuid field it will create a parser helper.

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

For some value types it will have IN clause.

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

For time.Time it will create these helper functions.

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

Easy RawSQL Usage

Enterprise can create complex queries but need for RawSQL always will be. Because of that you can use models.IDatabase to interact with pgx. We have plans to scan raw sql result to your db models or custom structs you create with relation if need.

Single db hit filter when join relation

One of the most important features that separates Enterprise from others is can join relations and filter them with single query.

One example is like this. Let's get a student's wrong answered test questions where test score higher than 80.

s := models.NewStudent(ctx, db)
s.Where(s.IsIDEqual(studentID))
s.WithTestList(func(testList *models.TestList) {
    testList.Where(
        testList.IsPointGreaterThan(80),
    )
    testList.Order(models.CreatedAtField)
    testList.WithQuestionList(func(questionList *models.QuestionList){
            questionList.Where(
                questionList.IsAnswerEqual(False),
            )
    })
})
err = s.Get()//row variables set to model and its relations struct.
if err != nil {
   log.Fatal(err)
}

For repository: https://github.com/MrSametBurgazoglu/enterprise
For documentation: https://mrsametburgazoglu.github.io/enterprise_docs/