Home

Jet

Jet is a framework for writing type-safe SQL queries in Go, with ability to easily convert database query result to desired arbitrary object structure.
Jet currently supports PostgreSQL, MySQL, MariaDB and SQLite. Future releases will add support for additional databases.

Jet is the easiest and fastest way to write complex SQL queries and map database query result into complex object composition. It is not an ORM.

Motivation

https://medium.com/@go.jet/jet-5f3667efa0cc

Installation

Use the command bellow to add jet as a dependency into go.mod project:

$ go get -u github.com/go-jet/jet/v2

Jet generator can be install in the following ways:

1. Install jet generator to GOPATH/bin folder:

cd $GOPATH/src/ && GO111MODULE=off go get -u github.com/go-jet/jet/cmd/jet

Make sure GOPATH/bin folder is added to the PATH environment variable.

2. Install jet generator to specific folder:

git clone https://github.com/go-jet/jet.git
cd jet && go build -o dir_path ./cmd/jet

Make sure dir_path folder is added to the PATH environment variable.

3. (Go1.16+) Install jet generator using go install:

go install github.com/go-jet/jet/v2/cmd/jet@latest

Jet generator is installed to the directory named by the GOBIN environment variable, which defaults to $GOPATH/bin or $HOME/go/bin if the GOPATH environment variable is not set.

Usage

Jet requires already defined database schema(with tables, views, enums etc), so that jet generator can generate SQL Builder and Model files. File generation is very fast, and can be added as every pre-build step. Sample command:

jet -dsn=postgresql://jet:jet@localhost:5432/jetdb -schema=dvds -path=./.gen

Detail info about jet generator can be found at Generator.

Then next step is to import generated SQL Builder and Model files and write SQL queries in Go:

import . "some_path/.gen/jetdb/dvds/table"
import "some_path/.gen/jetdb/dvds/model"

To write SQL queries for PostgreSQL import:

. "github.com/go-jet/jet/postgres"

To write SQL queries for MySQL and MariaDB import:

. "github.com/go-jet/jet/mysql"

*Dot import so that Go code resemble as much as native SQL. Dot import is not mandatory.

Write SQL:

// sub-query
rRatingFilms := SELECT(
		    Film.FilmID,
		    Film.Title,
		    Film.Rating,
	       ).
               FROM(Film).
	       WHERE(Film.Rating.EQ(enum.FilmRating.R)).
	       AsTable("rFilms")

// export column from sub-query
rFilmID := Film.FilmID.From(rRatingFilms)

// main-query
query := SELECT(
		Actor.AllColumns,
		FilmActor.AllColumns,
		rRatingFilms.AllColumns(),
	).
        FROM(
           rRatingFilms.
	     INNER_JOIN(FilmActor, FilmActor.FilmID.EQ(rFilmID)).
	     INNER_JOIN(Actor, Actor.ActorID.EQ(FilmActor.ActorID)
        ).
	ORDER_BY(rFilmID, Actor.ActorID)

Store result into desired destination:

var dest []struct {
	model.Film

	Actors []model.Actor
}

err := query.Query(db, &dest)