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.
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:
SOCIAL SHARE CARD GENERATOR