Be faster with Y. The simplest ORM-like framework for Golang. The purpose of the library is a pure data modeling from a scratch.
go get github.com/regeda/yYou can use both databases: MySQL (default) and Postgres.
If you wanted to use Postgres you should call SetBuilderProvider method once before any Y routine:
y.SetBuilderProvider(y.Postgres)Y has been tested with following drivers:
github.com/go-sql-driver/mysqlgithub.com/lib/pq
Fetch executes SELECT statement and returns a collection of objects.
type Account struct {
ID int64 `y:"id,pk"`
Name string `y:"name"`
}
c, err := y.New(Account{}).Fetch(db)
if err != nil {
log.Panicln(err)
}
log.Printf("%#v\n", c.List())FindBy modifies a query for custom selection.
type Order struct {
ID int64 `y:"id,pk"`
Price int `y:"price"`
}
c, err := y.New(Order{}).
FindBy(
func(b squirrel.SelectBuilder) squirrel.SelectBuilder {
return b.Where("price > ?", 10)
}).
Fetch(db)
if err != nil {
log.Panicln(err)
}
log.Printf("%#v\n", c.List())Load executes SELECT statement for one row and loads the object in self.
type Todo struct {
ID int64 `y:"id,pk"`
Title string `y:"title"`
}
todo := Todo{ID: 1}
err := y.New(&todo).Load(db)
if err != nil {
log.Panicln(err)
}
log.Printf("%#v\n", todo)Put executes INSERT statement and assigns auto-increment value.
type User struct {
ID int64 `y:"id,pk,autoincr"`
Name string `y:"name"`
}
user := User{Name: "Harry"}
_, err := y.New(&user).Put(db)
if err != nil {
log.Panicln(err)
}
log.Printf("%#v\n", user)You can use Put for batch statement also.
type Log struct {
Msg string
}
logs := []Log{
{"It"}, {"Works"},
}
affected, err := y.New(logs).Put(db)
if err != nil {
log.Panicln(err)
}
log.Printf("%#v\n", affected)Update executes UPDATE statement. The action compares origin and modified objects by their version in the database.
type Car struct {
ID int64 `y:"id,pk"`
Power int `y:"power"`
y.Versionable
}
var err error
car := Car{ID: 1}
err = y.New(&car).MustLoad(db).Update(db, y.Values{"power": 50})
if err != nil {
log.Panicln(err)
}
log.Printf("%#v\n", car)Delete executes DELETE statement. The action removes an object by primary keys.
type Account struct {
ID int64 `y:",pk"`
Email string
}
acc := Account{ID: 1}
affected, err := y.New(acc).Delete(db)
if err != nil {
log.Panicln(err)
}
log.Printf("Affected rows: %d\n", affected)Join builds relations by foreign keys
type Device struct {
ID int64 `y:",pk"`
UserID int64 `y:",fk"`
Name string
}
type User struct {
ID int64 `y:"id,pk"`
DeviceArray []*Device `y:"-"`
}
users, err := y.New(User{}).Fetch(db)
if err != nil {
log.Panicln(err)
}
if !users.Empty() {
devices, _ := y.New(Device{}).Join(db, users)
log.Printf("All users with their devices: %#v\n", users)
log.Printf("All devices: %#v\n", devices)
}Please, be free to make pull requests or issues posting.
MIT
Original source: https://github.com/regeda/y