package database

import (

"database/sql/driver"

"fmt"

"reflect"

"regexp"

"strings"

"github.com/google/uuid"

"github.com/lib/pq"

"github.com/jmoiron/sqlx/reflectx"

"github.com/coder/coder/coderd/util/slice"

)

var nameRegex = regexp.MustCompile(`@([a-zA-Z0-9_]+)`)

var dbmapper = reflectx.NewMapper("db")

var sqlValuer = reflect.TypeOf((*driver.Valuer)(nil)).Elem()

func bindNamed(query string, arg interface{}) (newQuery string, args []interface{}, err error) {

// We do not need to implement a sql parser to extract and replace the variable names.

// All names follow a simple regex.

names := nameRegex.FindAllString(query, -1)

// Get all unique names

names = slice.Unique(names)

// Replace all names with the correct index

for i, name := range names {

rpl := fmt.Sprintf("$%d", i+1)

query = strings.ReplaceAll(query, name, rpl)

// Remove the "@" prefix to match to the "db" struct tag.

names[i] = strings.TrimPrefix(name, "@")

}

arglist := make([]interface{}, 0, len(names))

// This comes straight from SQLx's implementation to get the values

// of the struct fields.

v := reflect.ValueOf(arg)

for v = reflect.ValueOf(arg); v.Kind() == reflect.Ptr; {

v = v.Elem()

}

// If there is only 1 argument, and the argument is not a struct, then

// the only argument is the value passed in. This is a nice shortcut

// for simple queries with 1 param like "id".

if v.Type().Kind() != reflect.Struct && len(names) == 1 {

arglist = append(arglist, pqValue(v))

return query, arglist, nil

}

err = dbmapper.TraversalsByNameFunc(v.Type(), names, func(i int, t []int) error {

if len(t) == 0 {

return fmt.Errorf("could not find name %s in %#v", names[i], arg)

}

val := reflectx.FieldByIndexesReadOnly(v, t)

arglist = append(arglist, pqValue(val))

return nil

})

if err != nil {

return "", nil, err

}

return query, arglist, nil

}

func pqValue(val reflect.Value) interface{} {

valI := val.Interface()

// Handle some custom types to make arguments easier to use.

switch valI.(type) {

// Feel free to add more types here as needed.

case []uuid.UUID:

return pq.Array(valI)

default:

return valI

}

}

GetWorkspaceBuildByID(ctx context.Context, id uuid.UUID) (WorkspaceBuildWithOwners, error)

}

type WorkspaceBuildWithOwners struct {

WorkspaceBuild

OrganizationID uuid.UUID `db:"organization_id" json:"organization_id"`

OwnerID uuid.UUID `db:"owner_id" json:"owner_id"`

}

func (q *sqlQuerier) GetWorkspaceBuildByID(ctx context.Context, id uuid.UUID) (WorkspaceBuildWithOwners, error) {

return sqlxGet[WorkspaceBuildWithOwners](ctx, q, "GetWorkspaceBuildByID", id)

package database

import (

"context"

"github.com/coder/coder/coderd/database/sqlxqueries"

"golang.org/x/xerrors"

)

func sqlxGet[RT any](ctx context.Context, q *sqlQuerier, queryName string, argument interface{}) (RT, error) {

var empty RT

query, err := sqlxqueries.Query(queryName, nil)

if err != nil {

return empty, xerrors.Errorf("get query: %w", err)

}

query, args, err := bindNamed(query, argument)

if err != nil {

return empty, xerrors.Errorf("bind named: %w", err)

}

// GetContext maps the results of the query to the items slice by struct

// db tags.

err = q.sdb.GetContext(ctx, &empty, query, args...)

if err != nil {

return empty, xerrors.Errorf("%s: %w", queryName, err)

}

return empty, nil

}

To edit template files, it is best to configure your IDE to work with go template files.

Required extension (Default Golang Extension): https://marketplace.visualstudio.com/items?itemName=golang.Go

The default extension [supports syntax highlighting](https://github.com/golang/vscode-go/wiki/features#go-template-syntax-highlighting), but requires a configuration change. You must add this section to your golang extension settings:

"gopls": {

"ui.semanticTokens": true

},

Unfortunately, the VSCode extension does not support both go template and postgres highlighting. You can switch between the two with:

1. `ctl + shift + p`

1. "Change language Mode"

1. "Postgres" or "Go Template File"

- Feel free to create a permanent file association with `*.gosql` files.

Goland supports [template highlighting](https://www.jetbrains.com/help/go/integration-with-go-templates.html) out of the box. To associate sql files, add a new file type in **Editor** settings. Select "Go template files". Add a new filename of `*.gosql` and select "postgres" as the "Template Data Language".


It also helps to support the sqlc type variables. You can do this by adding ["User Parameters"](https://www.jetbrains.com/help/datagrip/settings-tools-database-user-parameters.html) in database queries.


You can also add `dump.sql` as a DDL data source for proper table column recognition.

package sqlxqueries

import (

"bytes"

"embed"

"sync"

"text/template"

"golang.org/x/xerrors"

)

var sqlxQueries embed.FS

var (

// Only parse the queries once.

once sync.Once

cached *template.Template

cachedError error

)

func queries() (*template.Template, error) {

once.Do(func() {

tpls, err := template.ParseFS(sqlxQueries, "*.gosql")

if err != nil {

cachedError = xerrors.Errorf("developer error parse sqlx queries: %w", err)

}

cached = tpls

})

return cached, cachedError

}

func Query(name string, data interface{}) (string, error) {

tpls, err := queries()

if err != nil {

return "", err

}

var out bytes.Buffer

// TODO: Should we cache these?

err = tpls.ExecuteTemplate(&out, name, data)

if err != nil {

return "", xerrors.Errorf("execute template %s: %w", name, err)

}

return out.String(), nil

}

func GetWorkspaceBuildByID() (string, error) {

return Query("GetWorkspaceBuildByID", nil)

}

{{ define "GetWorkspaceBuildByID" }}

SELECT

workspace_builds.*,

workspaces.organization_id AS organization_id,

workspaces.owner_id AS workspace_owner_id

FROM

workspace_builds

INNER JOIN

workspaces ON workspace_builds.workspace_id = workspaces.id

WHERE

workspace_builds.id = @build_id

LIMIT

1;

{{ end }}

{{ define "GetWorkspaceBuildByJobID" }}

SELECT

workspace_builds.*,

workspaces.organization_id AS organization_id,

workspaces.owner_id AS workspace_owner_id

FROM

workspace_builds

INNER JOIN

workspaces ON workspace_builds.workspace_id = workspaces.id

WHERE

workspace_builds.job_id = @job_id

LIMIT

1;

{{ end }}