template

Documentation

Index

• Constants
• func GenerateQueryLogic(col string, column schema.Column) (methods, functions, imports []string)

Constants

const (
	EntityFields    = "$ENTITY_FIELDS$"
	ScanFields      = "$SCAN_FIELDS$"
	ReferenceFields = "$REFERENCE_FIELDS$"
)

const (
	PackageName         = "$PACKAGE_NAME$"
	StdlibImports       = "$STDLIB_IMPORTS$"
	RepositoriesPackage = "$REPOSITORIES_PACKAGE$"
	Type                = "$TYPE$"
	ColumnName          = "$COLUMN_NAME$"
	FuncName            = "$FUNC_NAME$"
	Operator            = "$OPERATOR$"
	Value               = "$VALUE$"

	Equals         = "Equals"
	Not            = "Not"
	Contains       = "Contains"
	ContainsNot    = "ContainsNot"
	StartsWith     = "StartsWith"
	StartsWithNot  = "StartsWithNot"
	EndsWith       = "EndsWith"
	EndsWithNot    = "EndsWithNot"
	GreaterThan    = "GreaterThan"
	GreaterOrEqual = "GreaterOrEqual"
	LessThan       = "LessThan"
	LessOrEqual    = "LessOrEqual"
	Before         = "Before"
	BeforeOrEqual  = "BeforeOrEqual"
	After          = "After"
	AfterOrEqual   = "AfterOrEqual"
)

const (
	QueryFile = `package ` + PackageName + `

import (
	` + StdlibImports + `

	"` + RepositoriesPackage + `query"
)

type Query struct {
	n query.Node
}

func (q Query) SQL() (string, []interface{}) {
	return q.n.SQL()
}

func (q Query) Or(in Query) Query {
	return Query{query.Node{
		Children: &[2]query.Node{q.n, in.n},
		Operator: query.Or,
	}}
}
`
	QueryMethod = `func (q Query) ` + FuncName + `(in ` + Type + `) Query {
	return Query{query.Node{
		Children: &[2]query.Node{q.n, ` + FuncName + `(in).n},
		Operator: query.And,
	}}
}
`
	QueryFunction = `func ` + FuncName + `(in ` + Type + `) Query {
	return Query{query.Node{
		Condition: query.Condition{
			Column:   "` + ColumnName + `",
			Operator: query.` + Operator + `,
			Value:    ` + Value + `,
		},
	}}
}
`
)

const (
	ReposStructFields = "$REPOS_STRUCT_FIELDS$"
	RepoInits         = "$REPO_INITS$"
)

const (
	Imports               = "$IMPORTS$"
	TableName             = "$TABLE_NAME$"
	QueryPackageName      = "$ENTITY_PACKAGE_NAME$"
	ColumnNames           = "$COLUMN_NAMES$"
	StatementPlaceholders = "$STATEMENT_PLACEHOLDERS$"
	ColumnAssignments     = "$COLUMN_ASSIGNMENTS$"
	EntityName            = "$ENTITY_NAME$"
	InFields              = "$IN_FIELDS$"
	PKCapture             = "$ID_CAPTURE$"
	FieldName             = "$PK_FIELD_NAME$"
	PKQuery               = "$PK_QUERY$"
	PKFields              = "$PK_FIELDS"
	SaveFuncs             = "$SAVE_FUNCS$"
)

const EntityFile = `package ` + PackageName + `

import (
	"database/sql"
	"fmt"

	` + Imports + `
)

type ` + EntityName + ` struct {
	` + EntityFields + `

	` + ReferenceFields + `

	persisted *` + EntityName + `
}

type ` + EntityName + `s struct {
	rs *sql.Rows
}

func (es *` + EntityName + `s) Next() bool {
	return es.rs.Next()
}

func (es *` + EntityName + `s) Scan(e *` + EntityName + `) (err error) {
	if e == nil {
		return fmt.Errorf("in ` + EntityName + `s.Scan: passed a nil entity")
	}

	err = es.rs.Scan(` + ScanFields + `)
	persisted := *e
	e.persisted = &persisted
	return err
}
`

const MultiPKCaptureTemplate = `
	e = in
	var eid int64
	eid, err = res.LastInsertId()
	e.Id = int32(eid)
	if err != nil {
		return e, err
	}
`

const NodeFile = `` /* 1205-byte string literal not displayed */

const PKFieldTemplate = FieldName + "(in.persisted." + FieldName + ")."

const PKQueryTemplate = `
	q, args := ` + QueryPackageName + `.Query{}.
		` + PKFields + `
		SQL()
`

const RepositoriesFile = `package ` + PackageName + `

import (
	"database/sql"
)

type TransactFunc func(func() error) error

type Repositories struct {
	` + ReposStructFields + `
}

func InitRepositories(db *sql.DB) (Repositories, TransactFunc) {
	baseRepo := &repository{db: db}
	return Repositories{
		` + RepoInits + `
	}, initTransact(baseRepo)
}

type repository struct {
	db   *sql.DB
	tx   *sql.Tx
	isTx bool
}

func (r repository) prepare(query string) (*sql.Stmt, error) {
	if r.isTx {
		return r.tx.Prepare(query)
	} else {
		return r.db.Prepare(query)
	}
}

func initTransact(r *repository) TransactFunc {
	return func(f func() error) (err error) {
		r.tx, err = r.db.Begin()
		r.isTx = true
		defer func() {
			r.isTx = false
			if err != nil {
				err = r.tx.Rollback()
			} else {
				err = r.tx.Commit()
			}
		}()

		if err == nil {
			err = f()
		}

		return
	}
}
`

const RepositoryFile = `package ` + PackageName + `

import (
	"database/sql"
	"fmt"
	
	` + Imports + `
)

const (
	insert` + EntityName + ` = "INSERT INTO ` + TableName + `" +
		" (` + ColumnNames + `) " +
		" VALUES (` + StatementPlaceholders + `);"
	update` + EntityName + ` = "UPDATE ` + TableName + `" +
		" SET ` + ColumnAssignments + ` %s;"
	select` + EntityName + ` = "SELECT ` + ColumnNames + ` FROM ` + TableName + ` %s;"
	delete` + EntityName + ` = "DELETE FROM ` + TableName + ` %s;"
)

type ` + EntityName + `Repository struct {
	*repository
}

func (r *` + EntityName + `Repository) FetchOne(query ` + QueryPackageName + `.Query) (ent ` + EntityName + `, err error) {
	var stmt *sql.Stmt
	// ensure the *sql.Stmt is closed after we're done with it
	defer func() {
		if stmt != nil {
			_ = stmt.Close()
		}
	}()

	conditions, args := query.SQL()
	stmt, err = r.prepare(fmt.Sprintf(select` + EntityName + `, conditions))
	if err != nil {
		return
	}

	row := stmt.QueryRow(args...)

	err = row.Scan(` + ScanFields + `)

	persisted := ent
	ent.persisted = &persisted

	return ent, err
}

func (r *` + EntityName + `Repository) Search(query ` + QueryPackageName + `.Query) (es ` + EntityName + `s, err error) {
	var stmt *sql.Stmt
	// ensure the *sql.Stmt is closed after we're done with it
	defer func() {
		if stmt != nil {
			_ = stmt.Close()
		}
	}()

	conditions, args := query.SQL()
	stmt, err = r.prepare(fmt.Sprintf(select` + EntityName + `, conditions))
	if err != nil {
		return es, err
	}

	es.rs, err = stmt.Query(args...)

	return es, err
}

` + SaveFuncs + `

`

const SaveWithPK = `func (r *` + EntityName + `Repository) Save(in ` + EntityName + `) (` + EntityName + `, error) {
	if in.persisted == nil {
		return r.insert(in)
	} else {
		return r.update(in)
	}
}

func (r *` + EntityName + `Repository) insert(in ` + EntityName + `) (e ` + EntityName + `, err error) {
	var (
		stmt *sql.Stmt
		res  sql.Result
	)
	// ensure the *sql.Stmt is closed after we're done with it
	defer func() {
		if stmt != nil {
			_ = stmt.Close()
		}
	}()

	stmt, err = r.prepare(insert` + EntityName + `)
	if err != nil {
		return e, err
	}

	res, err = stmt.Exec(` + InFields + `)
	if err != nil {
		return e, err
	}
` + PKCapture + `
	in = e
	e.persisted = &in

	return e, err
}

func (r *` + EntityName + `Repository) update(in ` + EntityName + `) (e ` + EntityName + `, err error) {
	var (
		stmt *sql.Stmt
	)
	// ensure the *sql.Stmt is closed after we're done with it
	defer func() {
		if stmt != nil {
			_ = stmt.Close()
		}
	}()
` + PKQuery + `
	stmt, err = r.prepare(fmt.Sprintf(update` + EntityName + `, q))
	if err != nil {
		return e, err
	}

	fields := []interface{}{` + InFields + `}
	_, err = stmt.Exec(append(fields, args...)...)
	if err != nil {
		return e, err
	}

	e = in
	in = e
	e.persisted = &in

	return e, err
}

func (r *` + EntityName + `Repository) Delete(query ` + QueryPackageName + `.Query) (err error) {
	var stmt *sql.Stmt
	// ensure the *sql.Stmt is closed after we're done with it
	defer func() {
		if stmt != nil {
			_ = stmt.Close()
		}
	}()

	conditions, args := query.SQL()
	stmt, err = r.prepare(fmt.Sprintf(delete` + EntityName + `, conditions))
	if err != nil {
		return err
	}

	_, err = stmt.Exec(args...)

	return err
}`

const SaveWithoutPK = `func (r *` + EntityName + `Repository) Save(in ` + EntityName + `) (` + EntityName + `, error) {
	var (
		stmt *sql.Stmt
		res  sql.Result
	)
	// ensure the *sql.Stmt is closed after we're done with it
	defer func() {
		if stmt != nil {
			_ = stmt.Close()
		}
	}()

	stmt, err = r.prepare(insert` + EntityName + `)
	if err != nil {
		return e, err
	}

	res, err = stmt.Exec(` + InFields + `)
	if err != nil {
		return e, err
	}
` + PKCapture + `
	in = e
	e.persisted = &in

	return e, err
}`

const SinglePKCaptureTemplate = `
	e = in
	var eid int64
	eid, err = res.LastInsertId()
	e.` + FieldName + ` = ` + Type + `(eid)
	if err != nil {
		return e, err
	}
`

Functions

func GenerateQueryLogic

func GenerateQueryLogic(col string, column schema.Column) (methods, functions, imports []string)