a lot of progress on items as well as get/find/create on project.

internal/database/mysql/mysqlcore/db.go

@@ -7,6 +7,7 @@ package mysqlcore
 import (
 	"context"
 	"database/sql"
+	"fmt"
 )
 
 type DBTX interface {
@@ -20,12 +21,498 @@ func New(db DBTX) *Queries {
 	return &Queries{db: db}
 }
 
+func Prepare(ctx context.Context, db DBTX) (*Queries, error) {
+	q := Queries{db: db}
+	var err error
+	if q.clearItemProjectRequirementStmt, err = db.PrepareContext(ctx, clearItemProjectRequirement); err != nil {
+		return nil, fmt.Errorf("error preparing query ClearItemProjectRequirement: %w", err)
+	}
+	if q.clearItemStatProgressStmt, err = db.PrepareContext(ctx, clearItemStatProgress); err != nil {
+		return nil, fmt.Errorf("error preparing query ClearItemStatProgress: %w", err)
+	}
+	if q.deleteAllScopeMembersStmt, err = db.PrepareContext(ctx, deleteAllScopeMembers); err != nil {
+		return nil, fmt.Errorf("error preparing query DeleteAllScopeMembers: %w", err)
+	}
+	if q.deleteItemStmt, err = db.PrepareContext(ctx, deleteItem); err != nil {
+		return nil, fmt.Errorf("error preparing query DeleteItem: %w", err)
+	}
+	if q.deleteItemForRequirementStmt, err = db.PrepareContext(ctx, deleteItemForRequirement); err != nil {
+		return nil, fmt.Errorf("error preparing query DeleteItemForRequirement: %w", err)
+	}
+	if q.deleteItemStatProgressStmt, err = db.PrepareContext(ctx, deleteItemStatProgress); err != nil {
+		return nil, fmt.Errorf("error preparing query DeleteItemStatProgress: %w", err)
+	}
+	if q.deleteProjectStmt, err = db.PrepareContext(ctx, deleteProject); err != nil {
+		return nil, fmt.Errorf("error preparing query DeleteProject: %w", err)
+	}
+	if q.deleteProjectRequirementStmt, err = db.PrepareContext(ctx, deleteProjectRequirement); err != nil {
+		return nil, fmt.Errorf("error preparing query DeleteProjectRequirement: %w", err)
+	}
+	if q.deleteScopeStmt, err = db.PrepareContext(ctx, deleteScope); err != nil {
+		return nil, fmt.Errorf("error preparing query DeleteScope: %w", err)
+	}
+	if q.deleteScopeMemberStmt, err = db.PrepareContext(ctx, deleteScopeMember); err != nil {
+		return nil, fmt.Errorf("error preparing query DeleteScopeMember: %w", err)
+	}
+	if q.getItemStmt, err = db.PrepareContext(ctx, getItem); err != nil {
+		return nil, fmt.Errorf("error preparing query GetItem: %w", err)
+	}
+	if q.getItemStatProgressBetweenStmt, err = db.PrepareContext(ctx, getItemStatProgressBetween); err != nil {
+		return nil, fmt.Errorf("error preparing query GetItemStatProgressBetween: %w", err)
+	}
+	if q.getProjectStmt, err = db.PrepareContext(ctx, getProject); err != nil {
+		return nil, fmt.Errorf("error preparing query GetProject: %w", err)
+	}
+	if q.getProjectRequirementStmt, err = db.PrepareContext(ctx, getProjectRequirement); err != nil {
+		return nil, fmt.Errorf("error preparing query GetProjectRequirement: %w", err)
+	}
+	if q.getScopeStmt, err = db.PrepareContext(ctx, getScope); err != nil {
+		return nil, fmt.Errorf("error preparing query GetScope: %w", err)
+	}
+	if q.getScopeDisplayNameStmt, err = db.PrepareContext(ctx, getScopeDisplayName); err != nil {
+		return nil, fmt.Errorf("error preparing query GetScopeDisplayName: %w", err)
+	}
+	if q.getScopeWithDisplayNameStmt, err = db.PrepareContext(ctx, getScopeWithDisplayName); err != nil {
+		return nil, fmt.Errorf("error preparing query GetScopeWithDisplayName: %w", err)
+	}
+	if q.insertItemStmt, err = db.PrepareContext(ctx, insertItem); err != nil {
+		return nil, fmt.Errorf("error preparing query InsertItem: %w", err)
+	}
+	if q.insertProjectStmt, err = db.PrepareContext(ctx, insertProject); err != nil {
+		return nil, fmt.Errorf("error preparing query InsertProject: %w", err)
+	}
+	if q.insertProjectRequirementStmt, err = db.PrepareContext(ctx, insertProjectRequirement); err != nil {
+		return nil, fmt.Errorf("error preparing query InsertProjectRequirement: %w", err)
+	}
+	if q.insertScopeStmt, err = db.PrepareContext(ctx, insertScope); err != nil {
+		return nil, fmt.Errorf("error preparing query InsertScope: %w", err)
+	}
+	if q.listItemStatProgressStmt, err = db.PrepareContext(ctx, listItemStatProgress); err != nil {
+		return nil, fmt.Errorf("error preparing query ListItemStatProgress: %w", err)
+	}
+	if q.listItemStatProgressMultiStmt, err = db.PrepareContext(ctx, listItemStatProgressMulti); err != nil {
+		return nil, fmt.Errorf("error preparing query ListItemStatProgressMulti: %w", err)
+	}
+	if q.listItemsAcquiredBetweenStmt, err = db.PrepareContext(ctx, listItemsAcquiredBetween); err != nil {
+		return nil, fmt.Errorf("error preparing query ListItemsAcquiredBetween: %w", err)
+	}
+	if q.listItemsByProjectStmt, err = db.PrepareContext(ctx, listItemsByProject); err != nil {
+		return nil, fmt.Errorf("error preparing query ListItemsByProject: %w", err)
+	}
+	if q.listItemsCreatedBetweenStmt, err = db.PrepareContext(ctx, listItemsCreatedBetween); err != nil {
+		return nil, fmt.Errorf("error preparing query ListItemsCreatedBetween: %w", err)
+	}
+	if q.listItemsCreatedBetweenNoScopeStmt, err = db.PrepareContext(ctx, listItemsCreatedBetweenNoScope); err != nil {
+		return nil, fmt.Errorf("error preparing query ListItemsCreatedBetweenNoScope: %w", err)
+	}
+	if q.listItemsLooseBetweenStmt, err = db.PrepareContext(ctx, listItemsLooseBetween); err != nil {
+		return nil, fmt.Errorf("error preparing query ListItemsLooseBetween: %w", err)
+	}
+	if q.listItemsLooseBetweenNoScopeStmt, err = db.PrepareContext(ctx, listItemsLooseBetweenNoScope); err != nil {
+		return nil, fmt.Errorf("error preparing query ListItemsLooseBetweenNoScope: %w", err)
+	}
+	if q.listItemsScheduledBetweenStmt, err = db.PrepareContext(ctx, listItemsScheduledBetween); err != nil {
+		return nil, fmt.Errorf("error preparing query ListItemsScheduledBetween: %w", err)
+	}
+	if q.listItemsScheduledBetweenNoScopeStmt, err = db.PrepareContext(ctx, listItemsScheduledBetweenNoScope); err != nil {
+		return nil, fmt.Errorf("error preparing query ListItemsScheduledBetweenNoScope: %w", err)
+	}
+	if q.listProjectEntriesStmt, err = db.PrepareContext(ctx, listProjectEntries); err != nil {
+		return nil, fmt.Errorf("error preparing query ListProjectEntries: %w", err)
+	}
+	if q.listProjectRequirementStatsStmt, err = db.PrepareContext(ctx, listProjectRequirementStats); err != nil {
+		return nil, fmt.Errorf("error preparing query ListProjectRequirementStats: %w", err)
+	}
+	if q.listProjectRequirementsByProjectIDStmt, err = db.PrepareContext(ctx, listProjectRequirementsByProjectID); err != nil {
+		return nil, fmt.Errorf("error preparing query ListProjectRequirementsByProjectID: %w", err)
+	}
+	if q.listScopeMembersStmt, err = db.PrepareContext(ctx, listScopeMembers); err != nil {
+		return nil, fmt.Errorf("error preparing query ListScopeMembers: %w", err)
+	}
+	if q.listScopesStmt, err = db.PrepareContext(ctx, listScopes); err != nil {
+		return nil, fmt.Errorf("error preparing query ListScopes: %w", err)
+	}
+	if q.listScopesByUserStmt, err = db.PrepareContext(ctx, listScopesByUser); err != nil {
+		return nil, fmt.Errorf("error preparing query ListScopesByUser: %w", err)
+	}
+	if q.listStatsStmt, err = db.PrepareContext(ctx, listStats); err != nil {
+		return nil, fmt.Errorf("error preparing query ListStats: %w", err)
+	}
+	if q.replaceItemStatProgressStmt, err = db.PrepareContext(ctx, replaceItemStatProgress); err != nil {
+		return nil, fmt.Errorf("error preparing query ReplaceItemStatProgress: %w", err)
+	}
+	if q.updateItemStmt, err = db.PrepareContext(ctx, updateItem); err != nil {
+		return nil, fmt.Errorf("error preparing query UpdateItem: %w", err)
+	}
+	if q.updateProjectStmt, err = db.PrepareContext(ctx, updateProject); err != nil {
+		return nil, fmt.Errorf("error preparing query UpdateProject: %w", err)
+	}
+	if q.updateProjectRequirementStmt, err = db.PrepareContext(ctx, updateProjectRequirement); err != nil {
+		return nil, fmt.Errorf("error preparing query UpdateProjectRequirement: %w", err)
+	}
+	if q.updateScopeStmt, err = db.PrepareContext(ctx, updateScope); err != nil {
+		return nil, fmt.Errorf("error preparing query UpdateScope: %w", err)
+	}
+	if q.updateScopeMemberStmt, err = db.PrepareContext(ctx, updateScopeMember); err != nil {
+		return nil, fmt.Errorf("error preparing query UpdateScopeMember: %w", err)
+	}
+	return &q, nil
+}
+
+func (q *Queries) Close() error {
+	var err error
+	if q.clearItemProjectRequirementStmt != nil {
+		if cerr := q.clearItemProjectRequirementStmt.Close(); cerr != nil {
+			err = fmt.Errorf("error closing clearItemProjectRequirementStmt: %w", cerr)
+		}
+	}
+	if q.clearItemStatProgressStmt != nil {
+		if cerr := q.clearItemStatProgressStmt.Close(); cerr != nil {
+			err = fmt.Errorf("error closing clearItemStatProgressStmt: %w", cerr)
+		}
+	}
+	if q.deleteAllScopeMembersStmt != nil {
+		if cerr := q.deleteAllScopeMembersStmt.Close(); cerr != nil {
+			err = fmt.Errorf("error closing deleteAllScopeMembersStmt: %w", cerr)
+		}
+	}
+	if q.deleteItemStmt != nil {
+		if cerr := q.deleteItemStmt.Close(); cerr != nil {
+			err = fmt.Errorf("error closing deleteItemStmt: %w", cerr)
+		}
+	}
+	if q.deleteItemForRequirementStmt != nil {
+		if cerr := q.deleteItemForRequirementStmt.Close(); cerr != nil {
+			err = fmt.Errorf("error closing deleteItemForRequirementStmt: %w", cerr)
+		}
+	}
+	if q.deleteItemStatProgressStmt != nil {
+		if cerr := q.deleteItemStatProgressStmt.Close(); cerr != nil {
+			err = fmt.Errorf("error closing deleteItemStatProgressStmt: %w", cerr)
+		}
+	}
+	if q.deleteProjectStmt != nil {
+		if cerr := q.deleteProjectStmt.Close(); cerr != nil {
+			err = fmt.Errorf("error closing deleteProjectStmt: %w", cerr)
+		}
+	}
+	if q.deleteProjectRequirementStmt != nil {
+		if cerr := q.deleteProjectRequirementStmt.Close(); cerr != nil {
+			err = fmt.Errorf("error closing deleteProjectRequirementStmt: %w", cerr)
+		}
+	}
+	if q.deleteScopeStmt != nil {
+		if cerr := q.deleteScopeStmt.Close(); cerr != nil {
+			err = fmt.Errorf("error closing deleteScopeStmt: %w", cerr)
+		}
+	}
+	if q.deleteScopeMemberStmt != nil {
+		if cerr := q.deleteScopeMemberStmt.Close(); cerr != nil {
+			err = fmt.Errorf("error closing deleteScopeMemberStmt: %w", cerr)
+		}
+	}
+	if q.getItemStmt != nil {
+		if cerr := q.getItemStmt.Close(); cerr != nil {
+			err = fmt.Errorf("error closing getItemStmt: %w", cerr)
+		}
+	}
+	if q.getItemStatProgressBetweenStmt != nil {
+		if cerr := q.getItemStatProgressBetweenStmt.Close(); cerr != nil {
+			err = fmt.Errorf("error closing getItemStatProgressBetweenStmt: %w", cerr)
+		}
+	}
+	if q.getProjectStmt != nil {
+		if cerr := q.getProjectStmt.Close(); cerr != nil {
+			err = fmt.Errorf("error closing getProjectStmt: %w", cerr)
+		}
+	}
+	if q.getProjectRequirementStmt != nil {
+		if cerr := q.getProjectRequirementStmt.Close(); cerr != nil {
+			err = fmt.Errorf("error closing getProjectRequirementStmt: %w", cerr)
+		}
+	}
+	if q.getScopeStmt != nil {
+		if cerr := q.getScopeStmt.Close(); cerr != nil {
+			err = fmt.Errorf("error closing getScopeStmt: %w", cerr)
+		}
+	}
+	if q.getScopeDisplayNameStmt != nil {
+		if cerr := q.getScopeDisplayNameStmt.Close(); cerr != nil {
+			err = fmt.Errorf("error closing getScopeDisplayNameStmt: %w", cerr)
+		}
+	}
+	if q.getScopeWithDisplayNameStmt != nil {
+		if cerr := q.getScopeWithDisplayNameStmt.Close(); cerr != nil {
+			err = fmt.Errorf("error closing getScopeWithDisplayNameStmt: %w", cerr)
+		}
+	}
+	if q.insertItemStmt != nil {
+		if cerr := q.insertItemStmt.Close(); cerr != nil {
+			err = fmt.Errorf("error closing insertItemStmt: %w", cerr)
+		}
+	}
+	if q.insertProjectStmt != nil {
+		if cerr := q.insertProjectStmt.Close(); cerr != nil {
+			err = fmt.Errorf("error closing insertProjectStmt: %w", cerr)
+		}
+	}
+	if q.insertProjectRequirementStmt != nil {
+		if cerr := q.insertProjectRequirementStmt.Close(); cerr != nil {
+			err = fmt.Errorf("error closing insertProjectRequirementStmt: %w", cerr)
+		}
+	}
+	if q.insertScopeStmt != nil {
+		if cerr := q.insertScopeStmt.Close(); cerr != nil {
+			err = fmt.Errorf("error closing insertScopeStmt: %w", cerr)
+		}
+	}
+	if q.listItemStatProgressStmt != nil {
+		if cerr := q.listItemStatProgressStmt.Close(); cerr != nil {
+			err = fmt.Errorf("error closing listItemStatProgressStmt: %w", cerr)
+		}
+	}
+	if q.listItemStatProgressMultiStmt != nil {
+		if cerr := q.listItemStatProgressMultiStmt.Close(); cerr != nil {
+			err = fmt.Errorf("error closing listItemStatProgressMultiStmt: %w", cerr)
+		}
+	}
+	if q.listItemsAcquiredBetweenStmt != nil {
+		if cerr := q.listItemsAcquiredBetweenStmt.Close(); cerr != nil {
+			err = fmt.Errorf("error closing listItemsAcquiredBetweenStmt: %w", cerr)
+		}
+	}
+	if q.listItemsByProjectStmt != nil {
+		if cerr := q.listItemsByProjectStmt.Close(); cerr != nil {
+			err = fmt.Errorf("error closing listItemsByProjectStmt: %w", cerr)
+		}
+	}
+	if q.listItemsCreatedBetweenStmt != nil {
+		if cerr := q.listItemsCreatedBetweenStmt.Close(); cerr != nil {
+			err = fmt.Errorf("error closing listItemsCreatedBetweenStmt: %w", cerr)
+		}
+	}
+	if q.listItemsCreatedBetweenNoScopeStmt != nil {
+		if cerr := q.listItemsCreatedBetweenNoScopeStmt.Close(); cerr != nil {
+			err = fmt.Errorf("error closing listItemsCreatedBetweenNoScopeStmt: %w", cerr)
+		}
+	}
+	if q.listItemsLooseBetweenStmt != nil {
+		if cerr := q.listItemsLooseBetweenStmt.Close(); cerr != nil {
+			err = fmt.Errorf("error closing listItemsLooseBetweenStmt: %w", cerr)
+		}
+	}
+	if q.listItemsLooseBetweenNoScopeStmt != nil {
+		if cerr := q.listItemsLooseBetweenNoScopeStmt.Close(); cerr != nil {
+			err = fmt.Errorf("error closing listItemsLooseBetweenNoScopeStmt: %w", cerr)
+		}
+	}
+	if q.listItemsScheduledBetweenStmt != nil {
+		if cerr := q.listItemsScheduledBetweenStmt.Close(); cerr != nil {
+			err = fmt.Errorf("error closing listItemsScheduledBetweenStmt: %w", cerr)
+		}
+	}
+	if q.listItemsScheduledBetweenNoScopeStmt != nil {
+		if cerr := q.listItemsScheduledBetweenNoScopeStmt.Close(); cerr != nil {
+			err = fmt.Errorf("error closing listItemsScheduledBetweenNoScopeStmt: %w", cerr)
+		}
+	}
+	if q.listProjectEntriesStmt != nil {
+		if cerr := q.listProjectEntriesStmt.Close(); cerr != nil {
+			err = fmt.Errorf("error closing listProjectEntriesStmt: %w", cerr)
+		}
+	}
+	if q.listProjectRequirementStatsStmt != nil {
+		if cerr := q.listProjectRequirementStatsStmt.Close(); cerr != nil {
+			err = fmt.Errorf("error closing listProjectRequirementStatsStmt: %w", cerr)
+		}
+	}
+	if q.listProjectRequirementsByProjectIDStmt != nil {
+		if cerr := q.listProjectRequirementsByProjectIDStmt.Close(); cerr != nil {
+			err = fmt.Errorf("error closing listProjectRequirementsByProjectIDStmt: %w", cerr)
+		}
+	}
+	if q.listScopeMembersStmt != nil {
+		if cerr := q.listScopeMembersStmt.Close(); cerr != nil {
+			err = fmt.Errorf("error closing listScopeMembersStmt: %w", cerr)
+		}
+	}
+	if q.listScopesStmt != nil {
+		if cerr := q.listScopesStmt.Close(); cerr != nil {
+			err = fmt.Errorf("error closing listScopesStmt: %w", cerr)
+		}
+	}
+	if q.listScopesByUserStmt != nil {
+		if cerr := q.listScopesByUserStmt.Close(); cerr != nil {
+			err = fmt.Errorf("error closing listScopesByUserStmt: %w", cerr)
+		}
+	}
+	if q.listStatsStmt != nil {
+		if cerr := q.listStatsStmt.Close(); cerr != nil {
+			err = fmt.Errorf("error closing listStatsStmt: %w", cerr)
+		}
+	}
+	if q.replaceItemStatProgressStmt != nil {
+		if cerr := q.replaceItemStatProgressStmt.Close(); cerr != nil {
+			err = fmt.Errorf("error closing replaceItemStatProgressStmt: %w", cerr)
+		}
+	}
+	if q.updateItemStmt != nil {
+		if cerr := q.updateItemStmt.Close(); cerr != nil {
+			err = fmt.Errorf("error closing updateItemStmt: %w", cerr)
+		}
+	}
+	if q.updateProjectStmt != nil {
+		if cerr := q.updateProjectStmt.Close(); cerr != nil {
+			err = fmt.Errorf("error closing updateProjectStmt: %w", cerr)
+		}
+	}
+	if q.updateProjectRequirementStmt != nil {
+		if cerr := q.updateProjectRequirementStmt.Close(); cerr != nil {
+			err = fmt.Errorf("error closing updateProjectRequirementStmt: %w", cerr)
+		}
+	}
+	if q.updateScopeStmt != nil {
+		if cerr := q.updateScopeStmt.Close(); cerr != nil {
+			err = fmt.Errorf("error closing updateScopeStmt: %w", cerr)
+		}
+	}
+	if q.updateScopeMemberStmt != nil {
+		if cerr := q.updateScopeMemberStmt.Close(); cerr != nil {
+			err = fmt.Errorf("error closing updateScopeMemberStmt: %w", cerr)
+		}
+	}
+	return err
+}
+
+func (q *Queries) exec(ctx context.Context, stmt *sql.Stmt, query string, args ...interface{}) (sql.Result, error) {
+	switch {
+	case stmt != nil && q.tx != nil:
+		return q.tx.StmtContext(ctx, stmt).ExecContext(ctx, args...)
+	case stmt != nil:
+		return stmt.ExecContext(ctx, args...)
+	default:
+		return q.db.ExecContext(ctx, query, args...)
+	}
+}
+
+func (q *Queries) query(ctx context.Context, stmt *sql.Stmt, query string, args ...interface{}) (*sql.Rows, error) {
+	switch {
+	case stmt != nil && q.tx != nil:
+		return q.tx.StmtContext(ctx, stmt).QueryContext(ctx, args...)
+	case stmt != nil:
+		return stmt.QueryContext(ctx, args...)
+	default:
+		return q.db.QueryContext(ctx, query, args...)
+	}
+}
+
+func (q *Queries) queryRow(ctx context.Context, stmt *sql.Stmt, query string, args ...interface{}) *sql.Row {
+	switch {
+	case stmt != nil && q.tx != nil:
+		return q.tx.StmtContext(ctx, stmt).QueryRowContext(ctx, args...)
+	case stmt != nil:
+		return stmt.QueryRowContext(ctx, args...)
+	default:
+		return q.db.QueryRowContext(ctx, query, args...)
+	}
+}
+
 type Queries struct {
-	db DBTX
+	db                                     DBTX
+	tx                                     *sql.Tx
+	clearItemProjectRequirementStmt        *sql.Stmt
+	clearItemStatProgressStmt              *sql.Stmt
+	deleteAllScopeMembersStmt              *sql.Stmt
+	deleteItemStmt                         *sql.Stmt
+	deleteItemForRequirementStmt           *sql.Stmt
+	deleteItemStatProgressStmt             *sql.Stmt
+	deleteProjectStmt                      *sql.Stmt
+	deleteProjectRequirementStmt           *sql.Stmt
+	deleteScopeStmt                        *sql.Stmt
+	deleteScopeMemberStmt                  *sql.Stmt
+	getItemStmt                            *sql.Stmt
+	getItemStatProgressBetweenStmt         *sql.Stmt
+	getProjectStmt                         *sql.Stmt
+	getProjectRequirementStmt              *sql.Stmt
+	getScopeStmt                           *sql.Stmt
+	getScopeDisplayNameStmt                *sql.Stmt
+	getScopeWithDisplayNameStmt            *sql.Stmt
+	insertItemStmt                         *sql.Stmt
+	insertProjectStmt                      *sql.Stmt
+	insertProjectRequirementStmt           *sql.Stmt
+	insertScopeStmt                        *sql.Stmt
+	listItemStatProgressStmt               *sql.Stmt
+	listItemStatProgressMultiStmt          *sql.Stmt
+	listItemsAcquiredBetweenStmt           *sql.Stmt
+	listItemsByProjectStmt                 *sql.Stmt
+	listItemsCreatedBetweenStmt            *sql.Stmt
+	listItemsCreatedBetweenNoScopeStmt     *sql.Stmt
+	listItemsLooseBetweenStmt              *sql.Stmt
+	listItemsLooseBetweenNoScopeStmt       *sql.Stmt
+	listItemsScheduledBetweenStmt          *sql.Stmt
+	listItemsScheduledBetweenNoScopeStmt   *sql.Stmt
+	listProjectEntriesStmt                 *sql.Stmt
+	listProjectRequirementStatsStmt        *sql.Stmt
+	listProjectRequirementsByProjectIDStmt *sql.Stmt
+	listScopeMembersStmt                   *sql.Stmt
+	listScopesStmt                         *sql.Stmt
+	listScopesByUserStmt                   *sql.Stmt
+	listStatsStmt                          *sql.Stmt
+	replaceItemStatProgressStmt            *sql.Stmt
+	updateItemStmt                         *sql.Stmt
+	updateProjectStmt                      *sql.Stmt
+	updateProjectRequirementStmt           *sql.Stmt
+	updateScopeStmt                        *sql.Stmt
+	updateScopeMemberStmt                  *sql.Stmt
 }
 
 func (q *Queries) WithTx(tx *sql.Tx) *Queries {
 	return &Queries{
-		db: tx,
+		db:                                     tx,
+		tx:                                     tx,
+		clearItemProjectRequirementStmt:        q.clearItemProjectRequirementStmt,
+		clearItemStatProgressStmt:              q.clearItemStatProgressStmt,
+		deleteAllScopeMembersStmt:              q.deleteAllScopeMembersStmt,
+		deleteItemStmt:                         q.deleteItemStmt,
+		deleteItemForRequirementStmt:           q.deleteItemForRequirementStmt,
+		deleteItemStatProgressStmt:             q.deleteItemStatProgressStmt,
+		deleteProjectStmt:                      q.deleteProjectStmt,
+		deleteProjectRequirementStmt:           q.deleteProjectRequirementStmt,
+		deleteScopeStmt:                        q.deleteScopeStmt,
+		deleteScopeMemberStmt:                  q.deleteScopeMemberStmt,
+		getItemStmt:                            q.getItemStmt,
+		getItemStatProgressBetweenStmt:         q.getItemStatProgressBetweenStmt,
+		getProjectStmt:                         q.getProjectStmt,
+		getProjectRequirementStmt:              q.getProjectRequirementStmt,
+		getScopeStmt:                           q.getScopeStmt,
+		getScopeDisplayNameStmt:                q.getScopeDisplayNameStmt,
+		getScopeWithDisplayNameStmt:            q.getScopeWithDisplayNameStmt,
+		insertItemStmt:                         q.insertItemStmt,
+		insertProjectStmt:                      q.insertProjectStmt,
+		insertProjectRequirementStmt:           q.insertProjectRequirementStmt,
+		insertScopeStmt:                        q.insertScopeStmt,
+		listItemStatProgressStmt:               q.listItemStatProgressStmt,
+		listItemStatProgressMultiStmt:          q.listItemStatProgressMultiStmt,
+		listItemsAcquiredBetweenStmt:           q.listItemsAcquiredBetweenStmt,
+		listItemsByProjectStmt:                 q.listItemsByProjectStmt,
+		listItemsCreatedBetweenStmt:            q.listItemsCreatedBetweenStmt,
+		listItemsCreatedBetweenNoScopeStmt:     q.listItemsCreatedBetweenNoScopeStmt,
+		listItemsLooseBetweenStmt:              q.listItemsLooseBetweenStmt,
+		listItemsLooseBetweenNoScopeStmt:       q.listItemsLooseBetweenNoScopeStmt,
+		listItemsScheduledBetweenStmt:          q.listItemsScheduledBetweenStmt,
+		listItemsScheduledBetweenNoScopeStmt:   q.listItemsScheduledBetweenNoScopeStmt,
+		listProjectEntriesStmt:                 q.listProjectEntriesStmt,
+		listProjectRequirementStatsStmt:        q.listProjectRequirementStatsStmt,
+		listProjectRequirementsByProjectIDStmt: q.listProjectRequirementsByProjectIDStmt,
+		listScopeMembersStmt:                   q.listScopeMembersStmt,
+		listScopesStmt:                         q.listScopesStmt,
+		listScopesByUserStmt:                   q.listScopesByUserStmt,
+		listStatsStmt:                          q.listStatsStmt,
+		replaceItemStatProgressStmt:            q.replaceItemStatProgressStmt,
+		updateItemStmt:                         q.updateItemStmt,
+		updateProjectStmt:                      q.updateProjectStmt,
+		updateProjectRequirementStmt:           q.updateProjectRequirementStmt,
+		updateScopeStmt:                        q.updateScopeStmt,
+		updateScopeMemberStmt:                  q.updateScopeMemberStmt,
 	}
 }

internal/database/mysql/mysqlcore/item.sql.go

@@ -13,12 +13,21 @@ import (
 	"git.aiterp.net/stufflog3/stufflog3-api/internal/sqltypes"
 )
 
+const clearItemProjectRequirement = `-- name: ClearItemProjectRequirement :exec
+UPDATE item SET project_requirement_id = NULL WHERE project_requirement_id = ?
+`
+
+func (q *Queries) ClearItemProjectRequirement(ctx context.Context, projectRequirementID sql.NullInt32) error {
+	_, err := q.exec(ctx, q.clearItemProjectRequirementStmt, clearItemProjectRequirement, projectRequirementID)
+	return err
+}
+
 const clearItemStatProgress = `-- name: ClearItemStatProgress :exec
 DELETE FROM item_stat_progress WHERE item_id = ?
 `
 
 func (q *Queries) ClearItemStatProgress(ctx context.Context, itemID int) error {
-	_, err := q.db.ExecContext(ctx, clearItemStatProgress, itemID)
+	_, err := q.exec(ctx, q.clearItemStatProgressStmt, clearItemStatProgress, itemID)
 	return err
 }
 
@@ -27,7 +36,16 @@ DELETE FROM item WHERE id = ?
 `
 
 func (q *Queries) DeleteItem(ctx context.Context, id int) error {
-	_, err := q.db.ExecContext(ctx, deleteItem, id)
+	_, err := q.exec(ctx, q.deleteItemStmt, deleteItem, id)
+	return err
+}
+
+const deleteItemForRequirement = `-- name: DeleteItemForRequirement :exec
+DELETE FROM item WHERE project_requirement_id = ?
+`
+
+func (q *Queries) DeleteItemForRequirement(ctx context.Context, projectRequirementID sql.NullInt32) error {
+	_, err := q.exec(ctx, q.deleteItemForRequirementStmt, deleteItemForRequirement, projectRequirementID)
 	return err
 }
 
@@ -41,7 +59,7 @@ type DeleteItemStatProgressParams struct {
 }
 
 func (q *Queries) DeleteItemStatProgress(ctx context.Context, arg DeleteItemStatProgressParams) error {
-	_, err := q.db.ExecContext(ctx, deleteItemStatProgress, arg.ItemID, arg.StatID)
+	_, err := q.exec(ctx, q.deleteItemStatProgressStmt, deleteItemStatProgress, arg.ItemID, arg.StatID)
 	return err
 }
 
@@ -65,7 +83,7 @@ type GetItemRow struct {
 }
 
 func (q *Queries) GetItem(ctx context.Context, id int) (GetItemRow, error) {
-	row := q.db.QueryRowContext(ctx, getItem, id)
+	row := q.queryRow(ctx, q.getItemStmt, getItem, id)
 	var i GetItemRow
 	err := row.Scan(
 		&i.ID,
@@ -107,7 +125,7 @@ type GetItemStatProgressBetweenRow struct {
 }
 
 func (q *Queries) GetItemStatProgressBetween(ctx context.Context, arg GetItemStatProgressBetweenParams) (GetItemStatProgressBetweenRow, error) {
-	row := q.db.QueryRowContext(ctx, getItemStatProgressBetween, arg.AcquiredTime, arg.AcquiredTime_2, arg.ScopeID)
+	row := q.queryRow(ctx, q.getItemStatProgressBetweenStmt, getItemStatProgressBetween, arg.AcquiredTime, arg.AcquiredTime_2, arg.ScopeID)
 	var i GetItemStatProgressBetweenRow
 	err := row.Scan(
 		&i.ID,
@@ -136,7 +154,7 @@ type InsertItemParams struct {
 }
 
 func (q *Queries) InsertItem(ctx context.Context, arg InsertItemParams) (sql.Result, error) {
-	return q.db.ExecContext(ctx, insertItem,
+	return q.exec(ctx, q.insertItemStmt, insertItem,
 		arg.ScopeID,
 		arg.ProjectRequirementID,
 		arg.Name,
@@ -163,7 +181,7 @@ type ListItemStatProgressRow struct {
 }
 
 func (q *Queries) ListItemStatProgress(ctx context.Context, itemID int) ([]ListItemStatProgressRow, error) {
-	rows, err := q.db.QueryContext(ctx, listItemStatProgress, itemID)
+	rows, err := q.query(ctx, q.listItemStatProgressStmt, listItemStatProgress, itemID)
 	if err != nil {
 		return nil, err
 	}
@@ -218,7 +236,7 @@ type ListItemStatProgressMultiRow struct {
 }
 
 func (q *Queries) ListItemStatProgressMulti(ctx context.Context, arg ListItemStatProgressMultiParams) ([]ListItemStatProgressMultiRow, error) {
-	rows, err := q.db.QueryContext(ctx, listItemStatProgressMulti,
+	rows, err := q.query(ctx, q.listItemStatProgressMultiStmt, listItemStatProgressMulti,
 		arg.ItemID,
 		arg.ItemID_2,
 		arg.ItemID_3,
@@ -260,8 +278,9 @@ const listItemsAcquiredBetween = `-- name: ListItemsAcquiredBetween :many
 SELECT i.id, i.scope_id, i.project_requirement_id, i.name, i.description, i.created_time, i.created_user_id, i.acquired_time, i.scheduled_date, pr.project_id FROM item i
 LEFT JOIN project_requirement pr ON pr.id = i.project_requirement_id
 WHERE i.acquired_time >= ?
-  AND i.acquired_time < ?
+  AND i.acquired_time <= ?
   AND i.scope_id = ?
+ORDER BY acquired_time DESC, created_time DESC
 `
 
 type ListItemsAcquiredBetweenParams struct {
@@ -284,7 +303,7 @@ type ListItemsAcquiredBetweenRow struct {
 }
 
 func (q *Queries) ListItemsAcquiredBetween(ctx context.Context, arg ListItemsAcquiredBetweenParams) ([]ListItemsAcquiredBetweenRow, error) {
-	rows, err := q.db.QueryContext(ctx, listItemsAcquiredBetween, arg.AcquiredTime, arg.AcquiredTime_2, arg.ScopeID)
+	rows, err := q.query(ctx, q.listItemsAcquiredBetweenStmt, listItemsAcquiredBetween, arg.AcquiredTime, arg.AcquiredTime_2, arg.ScopeID)
 	if err != nil {
 		return nil, err
 	}
@@ -337,7 +356,7 @@ type ListItemsByProjectRow struct {
 }
 
 func (q *Queries) ListItemsByProject(ctx context.Context, projectID int) ([]ListItemsByProjectRow, error) {
-	rows, err := q.db.QueryContext(ctx, listItemsByProject, projectID)
+	rows, err := q.query(ctx, q.listItemsByProjectStmt, listItemsByProject, projectID)
 	if err != nil {
 		return nil, err
 	}
@@ -374,8 +393,9 @@ const listItemsCreatedBetween = `-- name: ListItemsCreatedBetween :many
 SELECT i.id, i.scope_id, i.project_requirement_id, i.name, i.description, i.created_time, i.created_user_id, i.acquired_time, i.scheduled_date, pr.project_id FROM item i
 LEFT JOIN project_requirement pr ON pr.id = i.project_requirement_id
 WHERE i.created_time >= ?
-  AND i.created_time < ?
+  AND i.created_time <= ?
   AND i.scope_id = ?
+ORDER BY created_time DESC
 `
 
 type ListItemsCreatedBetweenParams struct {
@@ -398,7 +418,7 @@ type ListItemsCreatedBetweenRow struct {
 }
 
 func (q *Queries) ListItemsCreatedBetween(ctx context.Context, arg ListItemsCreatedBetweenParams) ([]ListItemsCreatedBetweenRow, error) {
-	rows, err := q.db.QueryContext(ctx, listItemsCreatedBetween, arg.CreatedTime, arg.CreatedTime_2, arg.ScopeID)
+	rows, err := q.query(ctx, q.listItemsCreatedBetweenStmt, listItemsCreatedBetween, arg.CreatedTime, arg.CreatedTime_2, arg.ScopeID)
 	if err != nil {
 		return nil, err
 	}
@@ -457,7 +477,7 @@ type ListItemsCreatedBetweenNoScopeRow struct {
 }
 
 func (q *Queries) ListItemsCreatedBetweenNoScope(ctx context.Context, arg ListItemsCreatedBetweenNoScopeParams) ([]ListItemsCreatedBetweenNoScopeRow, error) {
-	rows, err := q.db.QueryContext(ctx, listItemsCreatedBetweenNoScope, arg.CreatedTime, arg.CreatedTime_2)
+	rows, err := q.query(ctx, q.listItemsCreatedBetweenNoScopeStmt, listItemsCreatedBetweenNoScope, arg.CreatedTime, arg.CreatedTime_2)
 	if err != nil {
 		return nil, err
 	}
@@ -494,10 +514,12 @@ const listItemsLooseBetween = `-- name: ListItemsLooseBetween :many
 SELECT i.id, i.scope_id, i.project_requirement_id, i.name, i.description, i.created_time, i.created_user_id, i.acquired_time, i.scheduled_date, pr.project_id FROM item i
 LEFT JOIN project_requirement pr ON pr.id = i.project_requirement_id
 WHERE i.created_time >= ?
-  AND i.created_time < ?
+  AND i.created_time <= ?
   AND i.scope_id = ?
   AND i.scheduled_date IS NULL
   AND i.acquired_time IS NULL
+  AND i.project_requirement_id IS NULL
+ORDER BY created_time DESC
 `
 
 type ListItemsLooseBetweenParams struct {
@@ -520,7 +542,7 @@ type ListItemsLooseBetweenRow struct {
 }
 
 func (q *Queries) ListItemsLooseBetween(ctx context.Context, arg ListItemsLooseBetweenParams) ([]ListItemsLooseBetweenRow, error) {
-	rows, err := q.db.QueryContext(ctx, listItemsLooseBetween, arg.CreatedTime, arg.CreatedTime_2, arg.ScopeID)
+	rows, err := q.query(ctx, q.listItemsLooseBetweenStmt, listItemsLooseBetween, arg.CreatedTime, arg.CreatedTime_2, arg.ScopeID)
 	if err != nil {
 		return nil, err
 	}
@@ -581,7 +603,7 @@ type ListItemsLooseBetweenNoScopeRow struct {
 }
 
 func (q *Queries) ListItemsLooseBetweenNoScope(ctx context.Context, arg ListItemsLooseBetweenNoScopeParams) ([]ListItemsLooseBetweenNoScopeRow, error) {
-	rows, err := q.db.QueryContext(ctx, listItemsLooseBetweenNoScope, arg.CreatedTime, arg.CreatedTime_2)
+	rows, err := q.query(ctx, q.listItemsLooseBetweenNoScopeStmt, listItemsLooseBetweenNoScope, arg.CreatedTime, arg.CreatedTime_2)
 	if err != nil {
 		return nil, err
 	}
@@ -618,8 +640,9 @@ const listItemsScheduledBetween = `-- name: ListItemsScheduledBetween :many
 SELECT i.id, i.scope_id, i.project_requirement_id, i.name, i.description, i.created_time, i.created_user_id, i.acquired_time, i.scheduled_date, pr.project_id FROM item i
 LEFT JOIN project_requirement pr ON pr.id = i.project_requirement_id
 WHERE i.scheduled_date >= ?
-  AND i.scheduled_date < ?
+  AND i.scheduled_date <= ?
   AND i.scope_id = ?
+ORDER BY scheduled_date, created_time
 `
 
 type ListItemsScheduledBetweenParams struct {
@@ -642,7 +665,7 @@ type ListItemsScheduledBetweenRow struct {
 }
 
 func (q *Queries) ListItemsScheduledBetween(ctx context.Context, arg ListItemsScheduledBetweenParams) ([]ListItemsScheduledBetweenRow, error) {
-	rows, err := q.db.QueryContext(ctx, listItemsScheduledBetween, arg.ScheduledDate, arg.ScheduledDate_2, arg.ScopeID)
+	rows, err := q.query(ctx, q.listItemsScheduledBetweenStmt, listItemsScheduledBetween, arg.ScheduledDate, arg.ScheduledDate_2, arg.ScopeID)
 	if err != nil {
 		return nil, err
 	}
@@ -701,7 +724,7 @@ type ListItemsScheduledBetweenNoScopeRow struct {
 }
 
 func (q *Queries) ListItemsScheduledBetweenNoScope(ctx context.Context, arg ListItemsScheduledBetweenNoScopeParams) ([]ListItemsScheduledBetweenNoScopeRow, error) {
-	rows, err := q.db.QueryContext(ctx, listItemsScheduledBetweenNoScope, arg.ScheduledDate, arg.ScheduledDate_2)
+	rows, err := q.query(ctx, q.listItemsScheduledBetweenNoScopeStmt, listItemsScheduledBetweenNoScope, arg.ScheduledDate, arg.ScheduledDate_2)
 	if err != nil {
 		return nil, err
 	}
@@ -747,7 +770,7 @@ type ReplaceItemStatProgressParams struct {
 }
 
 func (q *Queries) ReplaceItemStatProgress(ctx context.Context, arg ReplaceItemStatProgressParams) error {
-	_, err := q.db.ExecContext(ctx, replaceItemStatProgress,
+	_, err := q.exec(ctx, q.replaceItemStatProgressStmt, replaceItemStatProgress,
 		arg.ItemID,
 		arg.StatID,
 		arg.Acquired,
@@ -778,7 +801,7 @@ type UpdateItemParams struct {
 }
 
 func (q *Queries) UpdateItem(ctx context.Context, arg UpdateItemParams) error {
-	_, err := q.db.ExecContext(ctx, updateItem,
+	_, err := q.exec(ctx, q.updateItemStmt, updateItem,
 		arg.ProjectRequirementID,
 		arg.Name,
 		arg.Description,

internal/database/mysql/mysqlcore/project.sql.go

@@ -7,14 +7,34 @@ package mysqlcore
 
 import (
 	"context"
+	"database/sql"
+	"time"
 )
 
+const deleteProject = `-- name: DeleteProject :exec
+DELETE FROM project WHERE id = ?
+`
+
+func (q *Queries) DeleteProject(ctx context.Context, id int) error {
+	_, err := q.exec(ctx, q.deleteProjectStmt, deleteProject, id)
+	return err
+}
+
+const deleteProjectRequirement = `-- name: DeleteProjectRequirement :exec
+DELETE FROM project_requirement WHERE id = ?
+`
+
+func (q *Queries) DeleteProjectRequirement(ctx context.Context, id int) error {
+	_, err := q.exec(ctx, q.deleteProjectRequirementStmt, deleteProjectRequirement, id)
+	return err
+}
+
 const getProject = `-- name: GetProject :one
 SELECT id, scope_id, author_id, name, status, description, created_time FROM project WHERE id = ?
 `
 
 func (q *Queries) GetProject(ctx context.Context, id int) (Project, error) {
-	row := q.db.QueryRowContext(ctx, getProject, id)
+	row := q.queryRow(ctx, q.getProjectStmt, getProject, id)
 	var i Project
 	err := row.Scan(
 		&i.ID,
@@ -28,20 +48,88 @@ func (q *Queries) GetProject(ctx context.Context, id int) (Project, error) {
 	return i, err
 }
 
+const getProjectRequirement = `-- name: GetProjectRequirement :one
+SELECT id, scope_id, project_id, name, status, description FROM project_requirement WHERE id = ?
+`
+
+func (q *Queries) GetProjectRequirement(ctx context.Context, id int) (ProjectRequirement, error) {
+	row := q.queryRow(ctx, q.getProjectRequirementStmt, getProjectRequirement, id)
+	var i ProjectRequirement
+	err := row.Scan(
+		&i.ID,
+		&i.ScopeID,
+		&i.ProjectID,
+		&i.Name,
+		&i.Status,
+		&i.Description,
+	)
+	return i, err
+}
+
+const insertProject = `-- name: InsertProject :execresult
+INSERT INTO project (scope_id, author_id, name, status, description, created_time)
+VALUES (?, ?, ?, ?, ?, ?)
+`
+
+type InsertProjectParams struct {
+	ScopeID     int
+	AuthorID    string
+	Name        string
+	Status      int
+	Description string
+	CreatedTime time.Time
+}
+
+func (q *Queries) InsertProject(ctx context.Context, arg InsertProjectParams) (sql.Result, error) {
+	return q.exec(ctx, q.insertProjectStmt, insertProject,
+		arg.ScopeID,
+		arg.AuthorID,
+		arg.Name,
+		arg.Status,
+		arg.Description,
+		arg.CreatedTime,
+	)
+}
+
+const insertProjectRequirement = `-- name: InsertProjectRequirement :execresult
+INSERT INTO project_requirement (scope_id, project_id, name, status, description)
+VALUES (?, ?, ?, ?, ?)
+`
+
+type InsertProjectRequirementParams struct {
+	ScopeID     int
+	ProjectID   int
+	Name        string
+	Status      int
+	Description string
+}
+
+func (q *Queries) InsertProjectRequirement(ctx context.Context, arg InsertProjectRequirementParams) (sql.Result, error) {
+	return q.exec(ctx, q.insertProjectRequirementStmt, insertProjectRequirement,
+		arg.ScopeID,
+		arg.ProjectID,
+		arg.Name,
+		arg.Status,
+		arg.Description,
+	)
+}
+
 const listProjectEntries = `-- name: ListProjectEntries :many
-SELECT id, name, status FROM project
+SELECT id, name, status, created_time, author_id FROM project
 WHERE scope_id = ?
 ORDER BY status, created_time
 `
 
 type ListProjectEntriesRow struct {
-	ID     int
-	Name   string
-	Status int
+	ID          int
+	Name        string
+	Status      int
+	CreatedTime time.Time
+	AuthorID    string
 }
 
 func (q *Queries) ListProjectEntries(ctx context.Context, scopeID int) ([]ListProjectEntriesRow, error) {
-	rows, err := q.db.QueryContext(ctx, listProjectEntries, scopeID)
+	rows, err := q.query(ctx, q.listProjectEntriesStmt, listProjectEntries, scopeID)
 	if err != nil {
 		return nil, err
 	}
@@ -49,7 +137,54 @@ func (q *Queries) ListProjectEntries(ctx context.Context, scopeID int) ([]ListPr
 	items := []ListProjectEntriesRow{}
 	for rows.Next() {
 		var i ListProjectEntriesRow
-		if err := rows.Scan(&i.ID, &i.Name, &i.Status); err != nil {
+		if err := rows.Scan(
+			&i.ID,
+			&i.Name,
+			&i.Status,
+			&i.CreatedTime,
+			&i.AuthorID,
+		); 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 listProjectRequirementStats = `-- name: ListProjectRequirementStats :many
+SELECT prs.required, s.id, s.name, s.weight FROM project_requirement_stat prs
+RIGHT JOIN stat s ON s.id = prs.stat_id
+WHERE project_requirement_id = ?
+`
+
+type ListProjectRequirementStatsRow struct {
+	Required sql.NullInt32
+	ID       int
+	Name     string
+	Weight   float64
+}
+
+func (q *Queries) ListProjectRequirementStats(ctx context.Context, projectRequirementID int) ([]ListProjectRequirementStatsRow, error) {
+	rows, err := q.query(ctx, q.listProjectRequirementStatsStmt, listProjectRequirementStats, projectRequirementID)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	items := []ListProjectRequirementStatsRow{}
+	for rows.Next() {
+		var i ListProjectRequirementStatsRow
+		if err := rows.Scan(
+			&i.Required,
+			&i.ID,
+			&i.Name,
+			&i.Weight,
+		); err != nil {
 			return nil, err
 		}
 		items = append(items, i)
@@ -68,7 +203,7 @@ SELECT id, scope_id, project_id, name, status, description FROM project_requirem
 `
 
 func (q *Queries) ListProjectRequirementsByProjectID(ctx context.Context, projectID int) ([]ProjectRequirement, error) {
-	rows, err := q.db.QueryContext(ctx, listProjectRequirementsByProjectID, projectID)
+	rows, err := q.query(ctx, q.listProjectRequirementsByProjectIDStmt, listProjectRequirementsByProjectID, projectID)
 	if err != nil {
 		return nil, err
 	}
@@ -96,3 +231,53 @@ func (q *Queries) ListProjectRequirementsByProjectID(ctx context.Context, projec
 	}
 	return items, nil
 }
+
+const updateProject = `-- name: UpdateProject :exec
+UPDATE project
+SET name = ?,
+    status = ?,
+    description = ?
+WHERE id = ?
+`
+
+type UpdateProjectParams struct {
+	Name        string
+	Status      int
+	Description string
+	ID          int
+}
+
+func (q *Queries) UpdateProject(ctx context.Context, arg UpdateProjectParams) error {
+	_, err := q.exec(ctx, q.updateProjectStmt, updateProject,
+		arg.Name,
+		arg.Status,
+		arg.Description,
+		arg.ID,
+	)
+	return err
+}
+
+const updateProjectRequirement = `-- name: UpdateProjectRequirement :exec
+UPDATE project_requirement
+SET name = ?,
+    status = ?,
+    description = ?
+WHERE id = ?
+`
+
+type UpdateProjectRequirementParams struct {
+	Name        string
+	Status      int
+	Description string
+	ID          int
+}
+
+func (q *Queries) UpdateProjectRequirement(ctx context.Context, arg UpdateProjectRequirementParams) error {
+	_, err := q.exec(ctx, q.updateProjectRequirementStmt, updateProjectRequirement,
+		arg.Name,
+		arg.Status,
+		arg.Description,
+		arg.ID,
+	)
+	return err
+}

internal/database/mysql/mysqlcore/scope.sql.go

@@ -15,7 +15,7 @@ DELETE FROM scope_member WHERE scope_id=?
 `
 
 func (q *Queries) DeleteAllScopeMembers(ctx context.Context, scopeID int) error {
-	_, err := q.db.ExecContext(ctx, deleteAllScopeMembers, scopeID)
+	_, err := q.exec(ctx, q.deleteAllScopeMembersStmt, deleteAllScopeMembers, scopeID)
 	return err
 }
 
@@ -24,7 +24,7 @@ DELETE FROM scope WHERE id=?
 `
 
 func (q *Queries) DeleteScope(ctx context.Context, id int) error {
-	_, err := q.db.ExecContext(ctx, deleteScope, id)
+	_, err := q.exec(ctx, q.deleteScopeStmt, deleteScope, id)
 	return err
 }
 
@@ -38,7 +38,7 @@ type DeleteScopeMemberParams struct {
 }
 
 func (q *Queries) DeleteScopeMember(ctx context.Context, arg DeleteScopeMemberParams) error {
-	_, err := q.db.ExecContext(ctx, deleteScopeMember, arg.ScopeID, arg.UserID)
+	_, err := q.exec(ctx, q.deleteScopeMemberStmt, deleteScopeMember, arg.ScopeID, arg.UserID)
 	return err
 }
 
@@ -48,7 +48,7 @@ WHERE id = ?
 `
 
 func (q *Queries) GetScope(ctx context.Context, id int) (Scope, error) {
-	row := q.db.QueryRowContext(ctx, getScope, id)
+	row := q.queryRow(ctx, q.getScopeStmt, getScope, id)
 	var i Scope
 	err := row.Scan(&i.ID, &i.Name, &i.Abbreviation)
 	return i, err
@@ -65,7 +65,7 @@ type GetScopeDisplayNameParams struct {
 }
 
 func (q *Queries) GetScopeDisplayName(ctx context.Context, arg GetScopeDisplayNameParams) (string, error) {
-	row := q.db.QueryRowContext(ctx, getScopeDisplayName, arg.UserID, arg.ScopeID)
+	row := q.queryRow(ctx, q.getScopeDisplayNameStmt, getScopeDisplayName, arg.UserID, arg.ScopeID)
 	var name string
 	err := row.Scan(&name)
 	return name, err
@@ -90,7 +90,7 @@ type GetScopeWithDisplayNameRow struct {
 }
 
 func (q *Queries) GetScopeWithDisplayName(ctx context.Context, arg GetScopeWithDisplayNameParams) (GetScopeWithDisplayNameRow, error) {
-	row := q.db.QueryRowContext(ctx, getScopeWithDisplayName, arg.ID, arg.UserID)
+	row := q.queryRow(ctx, q.getScopeWithDisplayNameStmt, getScopeWithDisplayName, arg.ID, arg.UserID)
 	var i GetScopeWithDisplayNameRow
 	err := row.Scan(
 		&i.ID,
@@ -113,7 +113,7 @@ type InsertScopeParams struct {
 }
 
 func (q *Queries) InsertScope(ctx context.Context, arg InsertScopeParams) (sql.Result, error) {
-	return q.db.ExecContext(ctx, insertScope, arg.ID, arg.Name, arg.Abbreviation)
+	return q.exec(ctx, q.insertScopeStmt, insertScope, arg.ID, arg.Name, arg.Abbreviation)
 }
 
 const listScopeMembers = `-- name: ListScopeMembers :many
@@ -129,7 +129,7 @@ type ListScopeMembersRow struct {
 }
 
 func (q *Queries) ListScopeMembers(ctx context.Context, scopeID int) ([]ListScopeMembersRow, error) {
-	rows, err := q.db.QueryContext(ctx, listScopeMembers, scopeID)
+	rows, err := q.query(ctx, q.listScopeMembersStmt, listScopeMembers, scopeID)
 	if err != nil {
 		return nil, err
 	}
@@ -157,7 +157,7 @@ ORDER BY name
 `
 
 func (q *Queries) ListScopes(ctx context.Context) ([]Scope, error) {
-	rows, err := q.db.QueryContext(ctx, listScopes)
+	rows, err := q.query(ctx, q.listScopesStmt, listScopes)
 	if err != nil {
 		return nil, err
 	}
@@ -194,7 +194,7 @@ type ListScopesByUserRow struct {
 }
 
 func (q *Queries) ListScopesByUser(ctx context.Context, userID string) ([]ListScopesByUserRow, error) {
-	rows, err := q.db.QueryContext(ctx, listScopesByUser, userID)
+	rows, err := q.query(ctx, q.listScopesByUserStmt, listScopesByUser, userID)
 	if err != nil {
 		return nil, err
 	}
@@ -232,7 +232,7 @@ type UpdateScopeParams struct {
 }
 
 func (q *Queries) UpdateScope(ctx context.Context, arg UpdateScopeParams) error {
-	_, err := q.db.ExecContext(ctx, updateScope, arg.Name, arg.Abbreviation, arg.ID)
+	_, err := q.exec(ctx, q.updateScopeStmt, updateScope, arg.Name, arg.Abbreviation, arg.ID)
 	return err
 }
 
@@ -249,7 +249,7 @@ type UpdateScopeMemberParams struct {
 }
 
 func (q *Queries) UpdateScopeMember(ctx context.Context, arg UpdateScopeMemberParams) error {
-	_, err := q.db.ExecContext(ctx, updateScopeMember,
+	_, err := q.exec(ctx, q.updateScopeMemberStmt, updateScopeMember,
 		arg.ScopeID,
 		arg.UserID,
 		arg.Name,

internal/database/mysql/mysqlcore/stats.sql.go

@@ -25,7 +25,7 @@ type ListStatsRow struct {
 }
 
 func (q *Queries) ListStats(ctx context.Context, scopeID int) ([]ListStatsRow, error) {
-	rows, err := q.db.QueryContext(ctx, listStats, scopeID)
+	rows, err := q.query(ctx, q.listStatsStmt, listStats, scopeID)
 	if err != nil {
 		return nil, err
 	}