A minimalistic relational database library for Go, with simple and familiar interface. Why?

• Install
• Initialize
• Define
  • Create & Drop Tables
  • Reset Tables
  • SQL Options
• CRUD:
  • Create
  • Read
    • Reading a single row
    • Reading multiple rows
    • Scanning to custom values
  • Update
  • Delete
  • Transactions
• Logs
• Custom Queries
• Running Tests
• Why another ORMish library for Go?
• Apps Using CRUD
• What's Missing?

$ go get github.com/azer/crud

import (
  "github.com/azer/crud"
  _ "github.com/go-sql-driver/mysql"
)

var DB *crud.DB

func init () {
  var err error
  DB, err = crud.Connect("mysql", os.Getenv("DATABASE_URL"))
  err = DB.Ping()
}

type User struct {
  Id int `sql:"auto-increment primary-key"`
  FirstName string
  LastName string
  ProfileId int
}

type Profile struct {
  Id int `sql:"auto-increment primary-key"`
  Bio string `sql:"text"`
}

CRUD will automatically convert column names from "FirstName" (CamelCase) to "first_name" (snake_case) for you. You can still choose custom names though;

type Post struct {
  Slug string `sql:"name=slug_id varchar(255) primary-key required"`
}

If no primary key is specified, CRUD will look for a field named "Id" with int type, and set it as auto-incrementing primary-key field.

CreateTables takes list of structs and makes sure they exist in the database.

err := DB.CreateTables(User{}, Profile{})

err := DB.DropTables(User{}, Profile{})

Shortcut for dropping and creating tables.

err := DB.ResetTables(User{}, Profile{})

CRUD tries to be smart about figuring out the best SQL options for your structs, and lets you choose manually, too. For example;

type Tweet struct {
 Text string `sql:"varchar(140) required name=tweet"`
}

Above example sets the type of the Text column as varchar(140), makes it required (NOT NULL) and changes the column name as tweet.

Here is the list of the options that you can pass;

• Types: int, bigint, varchar, text, date, time, timestamp
• auto-increment / autoincrement / auto_increment
• primary-key / primarykey / primary_key
• required
• default='?'
• name=?

If you'd like a struct field to be ignored by CRUD, choose - as options:

type Foo struct {
 IgnoreMe string `sql:"-"`
}

user := &User{1, "Foo", "Bar", 1}
err := DB.Create(user)

You can read single/multiple rows, or custom values, with the Read method.

user := &User{}
err := DB.Read(user, "WHERE id = ?", 1) // You can type the full query if preferred.
// => SELECT * FROM users WHERE id = 1

fmt.Println(user.Name)
// => Foo

users := []*User{}

err := DB.Read(&users)
// => SELECT * FROM users

fmt.Println(len(users))
// => 10

names := []string{}
err := DB.Read(&names, "SELECT name FROM users")

name := ""
err := DB.Read(&name, "SELECT name FROM users WHERE id=1")

totalUsers := 0
err := DB.Read(&totalUsers, "SELECT COUNT(id) FROM users"

Updates matching row in database, returns sql.ErrNoRows nothing matched.

user := &User{}
err := DB.Read(user, "WHERE id = ?", 1)

user.Name = "Yolo"
err := DB.Update(user)

Deletes matching row in database, returns sql.ErrNoRows nothing matched.

err := DB.Delete(&User{
  Id: 1
})

Use Begin method of a crud.DB instance to create a new transaction. Each transaction will provide you following methods;

• Commit
• Rollback
• Exec
• Query
• Create
• Read
• Update
• Delete

tx, err := DB.Begin()

err := tx.Create(&User{
  Name: "yolo"
})

err := tx.Delete(&User{
  Id: 123
})

err := tx.Commit()

If you want to see crud's internal logs, specify crud in the LOG environment variable when you run your app. For example;

$ LOG=crud go run myapp.go

(More info about how crud's logging work)

result, err := DB.Query("DROP DATABASE yolo") // or .Exec

DATABASE_URL="?" go test ./...

• Simplicity, taking more advantage of reflect library to keep the API simple.
• Building less things with more complete abstractions
• Handling errors in an idiomatic way
• Good test coverage
• Modular & reusable code
• Making less unsafe assumptions. e.g: not mapping structs to SQL rows by column index.

Listen Paradise is built with CRUD and it's open source.

• Migration: We need a sophisticated solution for adding / removing columns when user changes the structs.
• Explicit Read Methods: We can have explicit alternatives of Read method for people who prefers.
• Testing Transactions: Transactions work as expected but there is a sync bug in the test causing failure. It needs to be fixed.
• Custom Table Names: It needs to let people use custom table names.
• Comments: I rarely comment my code.
• Hooks: I'm not sure if this is needed, but worths to consider.

WTFPL