ChaiSQL
ChaiSQL is a modern embedded SQL database, focusing on flexibility and ease of use for developers. It provides a fresh alternative to traditional embedded databases by offering advanced features tailored for modern applications.
Key Features
- Modern SQL Experience: ChaiSQL introduces a modern twist to traditional SQL embedded databases
- Optimized for Go: Native Go implementation with no CGO dependency.
- Solid foundations: ChaiSQL is backed by Pebble for native Go toolchains, and RocksDB for non-Go or CGO builds (coming soon).
- Schema Flexibility: Support for strict, partial, and schemaless table designs, catering to various data modeling needs.
Roadmap
ChaiSQL is work in progress and is not ready yet for production.
Here is a high level list of features that we want to implement in the near future, in no particular order:
- Stable storage format (90% completed)
- Implement most of the SQL-92 standard (detailed roadmap coming soon)
- Provide clients for other languages (JS/TS, Python, etc) and add support for RocksDB as the backend
Installation
Install the ChaiSQL database
go install github.com/chaisql/chai
Quickstart
package main
import (
"context"
"fmt"
"log"
"github.com/chaisql/chai"
)
func main() {
// Create a database instance, here we'll store everything on-disk
db, err := chai.Open("mydb")
if err != nil {
log.Fatal(err)
}
defer db.Close()
// Create a table.
// Notice that it is possible to define constraints on nested columns.
err = db.Exec(`
CREATE TABLE user (
id INT PRIMARY KEY,
name TEXT NOT NULL UNIQUE,
created_at TIMESTAMP NOT NULL,
address (
city TEXT DEFAULT "unknown",
zipcode TEXT
),
friends ARRAY,
CHECK len(friends) > 0
)
`)
err = db.Exec(`
INSERT INTO user (id, name, age, address, friends)
VALUES (
11,
'Foo2',
20,
{city: "Lyon", zipcode: "69001"},
["foo", "bar", "baz"]
)`)
// Go structures can be passed directly
type User struct {
ID uint
Name string
TheAgeOfTheUser float64 `chai:"age"`
Address struct {
City string
ZipCode string
}
}
// Let's create a user
u := User{
ID: 20,
Name: "foo",
TheAgeOfTheUser: 40,
}
u.Address.City = "Lyon"
u.Address.ZipCode = "69001"
err = db.Exec(`INSERT INTO user VALUES ?`, &u)
// Query data
rows, err := db.Query("SELECT id, name, age, address FROM user WHERE age >= ?", 18)
defer rows.Close()
err = rows.Iterate(func(r *chai.Row) error {
err = r.Scan(...)
err = r.StructScan(...)
err = r.MapScan(...)
return nil
})
}
Checkout the Go doc and the usage example in the README to get started quickly.
In-memory database
For in-memory operations, simply use :memory::
db, err := chai.Open(":memory:")
Using database/sql
// import chai as a blank import
import _ "github.com/chaisql/chai/driver"
// Create a sql/database DB instance
db, err := sql.Open("chai", "mydb")
if err != nil {
log.Fatal(err)
}
defer db.Close()
// Then use db as usual
res, err := db.ExecContext(...)
res, err := db.Query(...)
res, err := db.QueryRow(...)
// use the driver.Scanner to scan into a struct
var u User
err = res.Scan(driver.Scanner(&u))
chai shell
The chai command line provides an SQL shell for database management:
go install github.com/chaisql/chai/cmd/chai@latest
Usage example:
# For in-memory database:
chai
# For disk-based database:
chai dirName
Contributing
Contributions are welcome!
A big thanks to our contributors!
Made with contrib.rocks.
For any questions or discussions, open an issue.