add sqlc and character table.

database/database.go

@@ -3,6 +3,7 @@ package database
 import (
 	"context"
 	"errors"
+	"git.aiterp.net/rpdata/api/database/postgres"
 
 	"git.aiterp.net/rpdata/api/database/mongodb"
 	"git.aiterp.net/rpdata/api/internal/config"
@@ -34,6 +35,8 @@ func Init(config config.Database) (Database, error) {
 	switch config.Driver {
 	case "mongo", "mgo", "mongodb":
 		return mongodb.Init(config)
+	case "postgres", "psql", "pq", "postgressql":
+		return postgres.Connect(config)
 	default:
 		return nil, ErrDriverUnrecognized
 	}

database/postgres/character.go

@@ -0,0 +1,224 @@
+package postgres
+
+import (
+	"context"
+	"database/sql"
+	"errors"
+	"fmt"
+	"git.aiterp.net/rpdata/api/database/postgres/psqlcore"
+	"git.aiterp.net/rpdata/api/models"
+	"strconv"
+	"strings"
+)
+
+var ErrNickConflict = errors.New("nick already in use by another character")
+
+type characterRepository struct {
+	insertWithIDs bool
+	db            *sql.DB
+}
+
+func (r *characterRepository) character(row psqlcore.DataCharacter) *models.Character {
+	return &models.Character{
+		ID:          strings.Trim(row.ID, " "),
+		Nicks:       row.Nicks,
+		Name:        row.Name,
+		ShortName:   row.ShortName,
+		Author:      row.Author,
+		Description: row.Description,
+	}
+}
+
+func (r *characterRepository) characters(rows []psqlcore.DataCharacter) []*models.Character {
+	results := make([]*models.Character, 0, len(rows))
+	for _, row := range rows {
+		results = append(results, r.character(row))
+	}
+
+	return results
+}
+
+func (r *characterRepository) Find(ctx context.Context, id string) (*models.Character, error) {
+	row, err := psqlcore.New(r.db).SelectCharacterByID(ctx, id)
+	if err != nil {
+		return nil, err
+	}
+
+	return r.character(row), nil
+}
+
+func (r *characterRepository) FindNick(ctx context.Context, nick string) (*models.Character, error) {
+	row, err := psqlcore.New(r.db).SelectCharacterByNick(ctx, nick)
+	if err != nil {
+		return nil, err
+	}
+
+	return r.character(row), nil
+}
+
+func (r *characterRepository) FindName(ctx context.Context, name string) (*models.Character, error) {
+	row, err := psqlcore.New(r.db).SelectCharacterByName(ctx, name)
+	if err != nil {
+		return nil, err
+	}
+
+	return r.character(row), nil
+}
+
+func (r *characterRepository) List(ctx context.Context, filter models.CharacterFilter) ([]*models.Character, error) {
+	params := psqlcore.SelectCharactersParams{
+		LimitSize: 10000,
+	}
+
+	if filter.IDs != nil {
+		params.FilterID = true
+		params.Ids = filter.IDs
+	}
+	if filter.Nicks != nil {
+		params.FilterNick = true
+		params.Nicks = filter.Nicks
+	}
+	if filter.Names != nil {
+		params.FilterName = true
+		params.Names = filter.Names
+	}
+	if filter.Author != nil {
+		params.FilterAuthor = true
+		params.Author = *filter.Author
+	}
+	if filter.Search != nil {
+		params.FilterSearch = true
+		params.Search = *filter.Search
+	}
+	if filter.Limit > 0 {
+		params.LimitSize = int32(filter.Limit)
+	}
+
+	rows, err := psqlcore.New(r.db).SelectCharacters(ctx, params)
+	if err != nil {
+		return nil, err
+	}
+
+	return r.characters(rows), nil
+}
+
+func (r *characterRepository) Insert(ctx context.Context, character models.Character) (*models.Character, error) {
+	tx, err := r.db.BeginTx(ctx, nil)
+	if err != nil {
+		return nil, err
+	}
+	defer func() { _ = tx.Rollback() }()
+
+	q := psqlcore.New(tx)
+
+	if !r.insertWithIDs || character.ID == "" {
+		next, err := q.IncrementCounter(ctx, "data_character_id")
+		if err != nil {
+			return nil, err
+		}
+
+		character.ID = fmt.Sprintf("C%d", next)
+	} else {
+		n, err := strconv.Atoi(character.ID[1:])
+		if err != nil {
+			return nil, err
+		}
+
+		err = q.BumpCounter(ctx, psqlcore.BumpCounterParams{ID: "data_character_id", Value: int32(n)})
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	rows, err := q.SelectCharacters(ctx, psqlcore.SelectCharactersParams{
+		FilterNick: true,
+		Nicks:      character.Nicks,
+		LimitSize:  1,
+	})
+	if err != nil {
+		return nil, fmt.Errorf("failed to select: %s", err)
+	}
+	if len(rows) != 0 {
+		return nil, ErrNickConflict
+	}
+
+	err = q.InsertCharacter(ctx, psqlcore.InsertCharacterParams{
+		ID:          character.ID,
+		Nicks:       character.Nicks,
+		Name:        character.Name,
+		ShortName:   character.ShortName,
+		Author:      character.Author,
+		Description: character.Description,
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	return &character, tx.Commit()
+}
+
+func (r *characterRepository) Update(ctx context.Context, character models.Character, update models.CharacterUpdate) (*models.Character, error) {
+	character.ApplyUpdate(update)
+
+	err := psqlcore.New(r.db).UpdateCharacter(ctx, psqlcore.UpdateCharacterParams{
+		ID:          character.ID,
+		Name:        character.Name,
+		ShortName:   character.ShortName,
+		Description: character.Description,
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	return &character, nil
+}
+
+func (r *characterRepository) AddNick(ctx context.Context, character models.Character, nick string) (*models.Character, error) {
+	tx, err := r.db.BeginTx(ctx, nil)
+	if err != nil {
+		return nil, err
+	}
+	defer func() { _ = tx.Rollback() }()
+
+	q := psqlcore.New(tx)
+
+	rows, err := q.SelectCharacters(ctx, psqlcore.SelectCharactersParams{
+		FilterNick: true,
+		Nicks:      []string{nick},
+		LimitSize:  1,
+	})
+	if err != nil {
+		return nil, err
+	}
+	if len(rows) != 0 {
+		return nil, ErrNickConflict
+	}
+
+	err = q.AddCharacterNick(ctx, psqlcore.AddCharacterNickParams{ID: character.ID, Nick: nick})
+	if err != nil {
+		return nil, err
+	}
+
+	character.Nicks = append(character.Nicks, nick)
+	return &character, nil
+}
+
+func (r *characterRepository) RemoveNick(ctx context.Context, character models.Character, nick string) (*models.Character, error) {
+	err := psqlcore.New(r.db).AddCharacterNick(ctx, psqlcore.AddCharacterNickParams{ID: character.ID, Nick: nick})
+	if err != nil {
+		return nil, err
+	}
+
+	for i, nick2 := range character.Nicks {
+		if nick2 == nick {
+			character.Nicks = append(character.Nicks[:i], character.Nicks[i+1:]...)
+			break
+		}
+	}
+
+	return &character, nil
+}
+
+func (r *characterRepository) Delete(ctx context.Context, character models.Character) error {
+	return psqlcore.New(r.db).DeleteCharacter(ctx, character.ID)
+}

database/postgres/db.go

@@ -0,0 +1,99 @@
+package postgres
+
+import (
+	"context"
+	"database/sql"
+	"fmt"
+	"git.aiterp.net/rpdata/api/database/postgres/psqlcore"
+	"git.aiterp.net/rpdata/api/internal/config"
+	"git.aiterp.net/rpdata/api/repositories"
+	"time"
+)
+
+func Connect(cfg config.Database) (*DB, error) {
+	sslMode := "disable"
+	if cfg.SSL {
+		sslMode = "enable"
+	}
+	psqlInfo := fmt.Sprintf("host=%s port=%d user=%s password=%s dbname=%s sslmode=%s",
+		cfg.Host, cfg.Port, cfg.Username, cfg.Password, cfg.Db, sslMode,
+	)
+
+	timeout, cancel := context.WithTimeout(context.Background(), time.Second*15)
+	defer cancel()
+
+	db, err := sql.Open("postgres", psqlInfo)
+	if err != nil {
+		return nil, err
+	}
+	if err := db.PingContext(timeout); err != nil {
+		return nil, err
+	}
+
+	q := psqlcore.New(db)
+	if err := q.EnsureCounter(timeout, "data_character_id"); err != nil {
+		return nil, err
+	}
+
+	return &DB{
+		db:            db,
+		insertWithIDs: cfg.RestoreIDs,
+	}, nil
+}
+
+type DB struct {
+	insertWithIDs bool
+	db            *sql.DB
+}
+
+func (d *DB) Changes() repositories.ChangeRepository {
+	panic("implement me")
+}
+
+func (d *DB) Channels() repositories.ChannelRepository {
+	panic("implement me")
+}
+
+func (d *DB) Characters() repositories.CharacterRepository {
+	return &characterRepository{insertWithIDs: d.insertWithIDs, db: d.db}
+}
+
+func (d *DB) Tags() repositories.TagRepository {
+	panic("implement me")
+}
+
+func (d *DB) Logs() repositories.LogRepository {
+	panic("implement me")
+}
+
+func (d *DB) Posts() repositories.PostRepository {
+	panic("implement me")
+}
+
+func (d *DB) Stories() repositories.StoryRepository {
+	panic("implement me")
+}
+
+func (d *DB) Chapters() repositories.ChapterRepository {
+	panic("implement me")
+}
+
+func (d *DB) Comments() repositories.CommentRepository {
+	panic("implement me")
+}
+
+func (d *DB) Keys() repositories.KeyRepository {
+	panic("implement me")
+}
+
+func (d *DB) Users() repositories.UserRepository {
+	panic("implement me")
+}
+
+func (d *DB) Files() repositories.FileRepository {
+	panic("implement me")
+}
+
+func (d *DB) Close(context.Context) error {
+	return d.db.Close()
+}

database/postgres/migrations/20210321134051_create_table_character.sql

@@ -0,0 +1,17 @@
+-- +goose Up
+-- +goose StatementBegin
+CREATE TABLE data_character (
+    id CHAR(8) NOT NULL PRIMARY KEY,
+    nicks TEXT[] NOT NULL,
+    name TEXT NOT NULL,
+    short_name TEXT NOT NULL,
+    author TEXT NOT NULL,
+    description TEXT NOT NULL,
+    ts_vector TSVECTOR NOT NULL
+);
+-- +goose StatementEnd
+
+-- +goose Down
+-- +goose StatementBegin
+DROP TABLE data_character;
+-- +goose StatementEnd

database/postgres/migrations/20210321140214_create_index_character_name.sql

@@ -0,0 +1,9 @@
+-- +goose Up
+-- +goose StatementBegin
+CREATE INDEX data_character_index_character_name ON data_character(name);
+-- +goose StatementEnd
+
+-- +goose Down
+-- +goose StatementBegin
+DROP INDEX IF EXISTS data_character_index_character_name;
+-- +goose StatementEnd

database/postgres/migrations/20210321140218_create_index_character_shortname.sql

@@ -0,0 +1,9 @@
+-- +goose Up
+-- +goose StatementBegin
+CREATE INDEX data_character_index_character_short_name ON data_character(short_name);
+-- +goose StatementEnd
+
+-- +goose Down
+-- +goose StatementBegin
+DROP INDEX IF EXISTS data_character_index_character_short_name;
+-- +goose StatementEnd

database/postgres/migrations/20210321140222_create_index_character_author.sql

@@ -0,0 +1,9 @@
+-- +goose Up
+-- +goose StatementBegin
+CREATE INDEX data_character_index_character_author ON data_character(author);
+-- +goose StatementEnd
+
+-- +goose Down
+-- +goose StatementBegin
+DROP INDEX IF EXISTS data_character_index_character_author;
+-- +goose StatementEnd

database/postgres/migrations/20210321163944_create_table_counter.sql

@@ -0,0 +1,12 @@
+-- +goose Up
+-- +goose StatementBegin
+CREATE TABLE core_counter (
+    id TEXT NOT NULL PRIMARY KEY,
+    value INTEGER
+);
+-- +goose StatementEnd
+
+-- +goose Down
+-- +goose StatementBegin
+DROP TABLE core_counter;
+-- +goose StatementEnd

database/postgres/migrations/20210321180234_create_index_character_nicks.sql

@@ -0,0 +1,9 @@
+-- +goose Up
+-- +goose StatementBegin
+CREATE INDEX data_character_index_character_nicks on data_character USING GIN (nicks);
+-- +goose StatementEnd
+
+-- +goose Down
+-- +goose StatementBegin
+DROP INDEX IF EXISTS data_character_index_character_nicks;
+-- +goose StatementEnd

database/postgres/migrations/20210321200000_create_function_immutable_array_to_string.sql

@@ -0,0 +1,15 @@
+-- +goose Up
+-- +goose StatementBegin
+CREATE FUNCTION immutable_array_to_string(arr ANYARRAY, sep TEXT)
+RETURNS text
+AS $$
+    SELECT array_to_string(arr, sep);
+$$
+LANGUAGE SQL
+IMMUTABLE;
+-- +goose StatementEnd
+
+-- +goose Down
+-- +goose StatementBegin
+DROP FUNCTION IF EXISTS immutable_array_to_string;
+-- +goose StatementEnd

database/postgres/migrations/20210321200155_create_index_character_search.sql

@@ -0,0 +1,9 @@
+-- +goose Up
+-- +goose StatementBegin
+CREATE INDEX data_character_index_search ON data_character USING GIN (ts_vector);
+-- +goose StatementEnd
+
+-- +goose Down
+-- +goose StatementBegin
+DROP INDEX IF EXISTS data_character_index_search;
+-- +goose StatementEnd

database/postgres/psqlcore/characters.sql.go

@@ -0,0 +1,235 @@
+// Code generated by sqlc. DO NOT EDIT.
+// source: characters.sql
+
+package psqlcore
+
+import (
+	"context"
+
+	"github.com/lib/pq"
+)
+
+const addCharacterNick = `-- name: AddCharacterNick :exec
+UPDATE data_character
+SET nicks=append(nicks, $1::text)
+WHERE id=$2::text
+`
+
+type AddCharacterNickParams struct {
+	Nick string `json:"nick"`
+	ID   string `json:"id"`
+}
+
+func (q *Queries) AddCharacterNick(ctx context.Context, arg AddCharacterNickParams) error {
+	_, err := q.db.ExecContext(ctx, addCharacterNick, arg.Nick, arg.ID)
+	return err
+}
+
+const deleteCharacter = `-- name: DeleteCharacter :exec
+DELETE FROM data_character WHERE id=$1
+`
+
+func (q *Queries) DeleteCharacter(ctx context.Context, id string) error {
+	_, err := q.db.ExecContext(ctx, deleteCharacter, id)
+	return err
+}
+
+const insertCharacter = `-- name: InsertCharacter :exec
+INSERT INTO data_character (id, nicks, name, short_name, author, description, ts_vector) VALUES (
+    $1::text, $2::text[], $3::text,
+    $4::text, $5::text, $6::text,
+    to_tsvector(
+        'english',
+        $3::text || ' ' || $6::text || ' ' || $5::text || ' '
+                             || immutable_array_to_string(
+            $2::text[], ' '
+        )
+    )
+)
+`
+
+type InsertCharacterParams struct {
+	ID          string   `json:"id"`
+	Nicks       []string `json:"nicks"`
+	Name        string   `json:"name"`
+	ShortName   string   `json:"short_name"`
+	Author      string   `json:"author"`
+	Description string   `json:"description"`
+}
+
+func (q *Queries) InsertCharacter(ctx context.Context, arg InsertCharacterParams) error {
+	_, err := q.db.ExecContext(ctx, insertCharacter,
+		arg.ID,
+		pq.Array(arg.Nicks),
+		arg.Name,
+		arg.ShortName,
+		arg.Author,
+		arg.Description,
+	)
+	return err
+}
+
+const removeCharacterNick = `-- name: RemoveCharacterNick :exec
+UPDATE data_character
+SET nicks=array_remove(nicks, $1::text)
+WHERE id=$2::text
+`
+
+type RemoveCharacterNickParams struct {
+	Nick string `json:"nick"`
+	ID   string `json:"id"`
+}
+
+func (q *Queries) RemoveCharacterNick(ctx context.Context, arg RemoveCharacterNickParams) error {
+	_, err := q.db.ExecContext(ctx, removeCharacterNick, arg.Nick, arg.ID)
+	return err
+}
+
+const selectCharacterByID = `-- name: SelectCharacterByID :one
+SELECT id, nicks, name, short_name, author, description, ts_vector FROM data_character WHERE id = $1::text
+`
+
+func (q *Queries) SelectCharacterByID(ctx context.Context, id string) (DataCharacter, error) {
+	row := q.db.QueryRowContext(ctx, selectCharacterByID, id)
+	var i DataCharacter
+	err := row.Scan(
+		&i.ID,
+		pq.Array(&i.Nicks),
+		&i.Name,
+		&i.ShortName,
+		&i.Author,
+		&i.Description,
+		&i.TsVector,
+	)
+	return i, err
+}
+
+const selectCharacterByName = `-- name: SelectCharacterByName :one
+SELECT id, nicks, name, short_name, author, description, ts_vector FROM data_character WHERE name = $1::text
+`
+
+func (q *Queries) SelectCharacterByName(ctx context.Context, name string) (DataCharacter, error) {
+	row := q.db.QueryRowContext(ctx, selectCharacterByName, name)
+	var i DataCharacter
+	err := row.Scan(
+		&i.ID,
+		pq.Array(&i.Nicks),
+		&i.Name,
+		&i.ShortName,
+		&i.Author,
+		&i.Description,
+		&i.TsVector,
+	)
+	return i, err
+}
+
+const selectCharacterByNick = `-- name: SelectCharacterByNick :one
+SELECT id, nicks, name, short_name, author, description, ts_vector FROM data_character WHERE nicks <@ ARRAY[$1::text]
+`
+
+func (q *Queries) SelectCharacterByNick(ctx context.Context, nick string) (DataCharacter, error) {
+	row := q.db.QueryRowContext(ctx, selectCharacterByNick, nick)
+	var i DataCharacter
+	err := row.Scan(
+		&i.ID,
+		pq.Array(&i.Nicks),
+		&i.Name,
+		&i.ShortName,
+		&i.Author,
+		&i.Description,
+		&i.TsVector,
+	)
+	return i, err
+}
+
+const selectCharacters = `-- name: SelectCharacters :many
+SELECT id, nicks, name, short_name, author, description, ts_vector FROM data_character
+WHERE ($1::bool = false OR id = ANY($2::text[]))
+    AND ($3::bool = false OR name = ANY($4::text[]))
+    AND ($5::bool = false OR nicks && ($6::text[]))
+    AND ($7::bool = false OR author = $8::text)
+    AND ($9::bool = false OR "ts_vector" @@ to_tsquery($10::text))
+LIMIT $11::int
+`
+
+type SelectCharactersParams struct {
+	FilterID     bool     `json:"filter_id"`
+	Ids          []string `json:"ids"`
+	FilterName   bool     `json:"filter_name"`
+	Names        []string `json:"names"`
+	FilterNick   bool     `json:"filter_nick"`
+	Nicks        []string `json:"nicks"`
+	FilterAuthor bool     `json:"filter_author"`
+	Author       string   `json:"author"`
+	FilterSearch bool     `json:"filter_search"`
+	Search       string   `json:"search"`
+	LimitSize    int32    `json:"limit_size"`
+}
+
+func (q *Queries) SelectCharacters(ctx context.Context, arg SelectCharactersParams) ([]DataCharacter, error) {
+	rows, err := q.db.QueryContext(ctx, selectCharacters,
+		arg.FilterID,
+		pq.Array(arg.Ids),
+		arg.FilterName,
+		pq.Array(arg.Names),
+		arg.FilterNick,
+		pq.Array(arg.Nicks),
+		arg.FilterAuthor,
+		arg.Author,
+		arg.FilterSearch,
+		arg.Search,
+		arg.LimitSize,
+	)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	items := []DataCharacter{}
+	for rows.Next() {
+		var i DataCharacter
+		if err := rows.Scan(
+			&i.ID,
+			pq.Array(&i.Nicks),
+			&i.Name,
+			&i.ShortName,
+			&i.Author,
+			&i.Description,
+			&i.TsVector,
+		); err != nil {
+			return nil, err
+		}
+		items = append(items, i)
+	}
+	if err := rows.Close(); err != nil {
+		return nil, err
+	}
+	if err := rows.Err(); err != nil {
+		return nil, err
+	}
+	return items, nil
+}
+
+const updateCharacter = `-- name: UpdateCharacter :exec
+UPDATE data_character
+SET name=$1::text,
+    short_name=$2::text,
+    description=$3::text
+WHERE id=$4::text
+`
+
+type UpdateCharacterParams struct {
+	Name        string `json:"name"`
+	ShortName   string `json:"short_name"`
+	Description string `json:"description"`
+	ID          string `json:"id"`
+}
+
+func (q *Queries) UpdateCharacter(ctx context.Context, arg UpdateCharacterParams) error {
+	_, err := q.db.ExecContext(ctx, updateCharacter,
+		arg.Name,
+		arg.ShortName,
+		arg.Description,
+		arg.ID,
+	)
+	return err
+}

database/postgres/psqlcore/counter.sql.go

@@ -0,0 +1,42 @@
+// Code generated by sqlc. DO NOT EDIT.
+// source: counter.sql
+
+package psqlcore
+
+import (
+	"context"
+)
+
+const bumpCounter = `-- name: BumpCounter :exec
+UPDATE core_counter SET value = value + 1 WHERE id = $1::text AND value <= $2::int
+`
+
+type BumpCounterParams struct {
+	ID    string `json:"id"`
+	Value int32  `json:"value"`
+}
+
+func (q *Queries) BumpCounter(ctx context.Context, arg BumpCounterParams) error {
+	_, err := q.db.ExecContext(ctx, bumpCounter, arg.ID, arg.Value)
+	return err
+}
+
+const ensureCounter = `-- name: EnsureCounter :exec
+INSERT INTO core_counter (id, value) VALUES ($1::text, 0) ON CONFLICT DO NOTHING
+`
+
+func (q *Queries) EnsureCounter(ctx context.Context, dollar_1 string) error {
+	_, err := q.db.ExecContext(ctx, ensureCounter, dollar_1)
+	return err
+}
+
+const incrementCounter = `-- name: IncrementCounter :one
+UPDATE core_counter SET value = value + 1 WHERE id = $1::text RETURNING value::int
+`
+
+func (q *Queries) IncrementCounter(ctx context.Context, dollar_1 string) (int32, error) {
+	row := q.db.QueryRowContext(ctx, incrementCounter, dollar_1)
+	var value int32
+	err := row.Scan(&value)
+	return value, err
+}

database/postgres/psqlcore/db.go

@@ -0,0 +1,29 @@
+// Code generated by sqlc. DO NOT EDIT.
+
+package psqlcore
+
+import (
+	"context"
+	"database/sql"
+)
+
+type DBTX interface {
+	ExecContext(context.Context, string, ...interface{}) (sql.Result, error)
+	PrepareContext(context.Context, string) (*sql.Stmt, error)
+	QueryContext(context.Context, string, ...interface{}) (*sql.Rows, error)
+	QueryRowContext(context.Context, string, ...interface{}) *sql.Row
+}
+
+func New(db DBTX) *Queries {
+	return &Queries{db: db}
+}
+
+type Queries struct {
+	db DBTX
+}
+
+func (q *Queries) WithTx(tx *sql.Tx) *Queries {
+	return &Queries{
+		db: tx,
+	}
+}

database/postgres/psqlcore/models.go

@@ -0,0 +1,22 @@
+// Code generated by sqlc. DO NOT EDIT.
+
+package psqlcore
+
+import (
+	"database/sql"
+)
+
+type CoreCounter struct {
+	ID    string        `json:"id"`
+	Value sql.NullInt32 `json:"value"`
+}
+
+type DataCharacter struct {
+	ID          string      `json:"id"`
+	Nicks       []string    `json:"nicks"`
+	Name        string      `json:"name"`
+	ShortName   string      `json:"short_name"`
+	Author      string      `json:"author"`
+	Description string      `json:"description"`
+	TsVector    interface{} `json:"ts_vector"`
+}

database/postgres/psqlcore/package.go

@@ -0,0 +1,4 @@
+//go:generate go run github.com/kyleconroy/sqlc/cmd/sqlc generate -f ../../../sqlc.yaml
+
+// Package psqlcore contains the generated code for the PostgresSQL drivers. It's generated using sqlc.
+package psqlcore

database/postgres/queries/characters.sql

@@ -0,0 +1,50 @@
+-- name: SelectCharacterByID :one
+SELECT * FROM data_character WHERE id = sqlc.arg(id)::text;
+
+-- name: SelectCharacterByNick :one
+SELECT * FROM data_character WHERE nicks <@ ARRAY[sqlc.arg(nick)::text];
+
+-- name: SelectCharacterByName :one
+SELECT * FROM data_character WHERE name = sqlc.arg(name)::text;
+
+-- name: SelectCharacters :many
+SELECT * FROM data_character
+WHERE (sqlc.arg(filter_id)::bool = false OR id = ANY(sqlc.arg(ids)::text[]))
+    AND (sqlc.arg(filter_name)::bool = false OR name = ANY(sqlc.arg(names)::text[]))
+    AND (sqlc.arg(filter_nick)::bool = false OR nicks && (sqlc.arg(nicks)::text[]))
+    AND (sqlc.arg(filter_author)::bool = false OR author = sqlc.arg(author)::text)
+    AND (sqlc.arg(filter_search)::bool = false OR "ts_vector" @@ to_tsquery(sqlc.arg(search)::text))
+LIMIT sqlc.arg(limit_size)::int;
+
+-- name: InsertCharacter :exec
+INSERT INTO data_character (id, nicks, name, short_name, author, description, ts_vector) VALUES (
+    sqlc.arg(id)::text, sqlc.arg(nicks)::text[], sqlc.arg(name)::text,
+    sqlc.arg(short_name)::text, sqlc.arg(author)::text, sqlc.arg(description)::text,
+    to_tsvector(
+        'english',
+        sqlc.arg(name)::text || ' ' || sqlc.arg(description)::text || ' ' || sqlc.arg(author)::text || ' '
+                             || immutable_array_to_string(
+            sqlc.arg(nicks)::text[], ' '
+        )
+    )
+);
+
+-- name: UpdateCharacter :exec
+UPDATE data_character
+SET name=sqlc.arg(name)::text,
+    short_name=sqlc.arg(short_name)::text,
+    description=sqlc.arg(description)::text
+WHERE id=sqlc.arg(id)::text;
+
+-- name: AddCharacterNick :exec
+UPDATE data_character
+SET nicks=append(nicks, sqlc.arg(nick)::text)
+WHERE id=sqlc.arg(id)::text;
+
+-- name: RemoveCharacterNick :exec
+UPDATE data_character
+SET nicks=array_remove(nicks, sqlc.arg(nick)::text)
+WHERE id=sqlc.arg(id)::text;
+
+-- name: DeleteCharacter :exec
+DELETE FROM data_character WHERE id=$1;

database/postgres/queries/counter.sql

@@ -0,0 +1,8 @@
+-- name: EnsureCounter :exec
+INSERT INTO core_counter (id, value) VALUES ($1::text, 0) ON CONFLICT DO NOTHING;
+
+-- name: IncrementCounter :one
+UPDATE core_counter SET value = value + 1 WHERE id = $1::text RETURNING value::int;
+
+-- name: BumpCounter :exec
+UPDATE core_counter SET value = value + 1 WHERE id = sqlc.arg(id)::text AND value <= sqlc.arg(value)::int;