sqlx

sqlx

For fun and performance.

There are no benchmarks, because while reflection is slow, network and io are even worse. This library is just to make me satisfied, not the CPU or machine power.

<(￣︶￣)↗[GO!]

show case

type User struct {
    ID int64 `db:"id"`
    Name string `db:"name"`
    Age int64 `db:"age"`
    Amount int64 `db:"amount"`
}

stmt := sqlx.NewLazyStmt(`select * from user where id > ${min_id} limit 100`);

_ = sqlx.InitAllLazyStmts(ctx)

type FindArgs struct {
    MinID int64 `args:"min_id"`
}

// Read first user
someone, err := sqlx.First[User](ctx, stmt, FindArgs{MinID: 100}, FindArgs{MinID: 100}) // yes, you can pass multiple args, override.

// Read all users
users, err := sqlx.All[User](ctx, stmt, sizehint: 100, FindArgs{MinID: 100}) // sizehint is the expected size of the result, for pre-allocation.


// in map/reduce,
//     - you can not hold the ele ptr, because the memory will be reused.
//     - safe to use in parallel.

// Map
year := time.Now().Year()
mapop := sqlx.NewMap[User, int64](stmt, func(ctx context.Context, ele *User) (int64, error) { return year - ele.Age, nil })

for birthYear, err := range mapop.Iter(ctx) {
    if err != nil {
        break
    }
}

// Reduce
reduceop := sqlx.NewReduce[User, int64](func(ctx context.Context, prev int64, ele *User) (int64, error) { return prev + ele.Amount, nil })
wg := sync.WaitGroup{}
for i := range 1000 {
    wg.Add(1)
    go func() {
        defer wg.Done()
        sum, err := reduceop.Calc(ctx, 0, FindArgs{MinID: 100 * i})
    }()
}
wg.Wait()

todo

• Add more tests.
• Add more dialects.
  • SQLite
  • MySQL
  • ...