stufflog3/ports/mysql/mysqlcore/db.go

// Code generated by sqlc. DO NOT EDIT.
// versions:
//   sqlc v1.13.0

package mysqlcore

import (
	"context"
	"database/sql"
	"fmt"
)

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}
}

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.clearItemStatProgressByStatStmt, err = db.PrepareContext(ctx, clearItemStatProgressByStat); err != nil {
		return nil, fmt.Errorf("error preparing query ClearItemStatProgressByStat: %w", err)
	}
	if q.clearProjectRequirementStatsByStatStmt, err = db.PrepareContext(ctx, clearProjectRequirementStatsByStat); err != nil {
		return nil, fmt.Errorf("error preparing query ClearProjectRequirementStatsByStat: %w", err)
	}
	if q.deleteAllItemStatProgressByStatIdStmt, err = db.PrepareContext(ctx, deleteAllItemStatProgressByStatId); err != nil {
		return nil, fmt.Errorf("error preparing query DeleteAllItemStatProgressByStatId: %w", err)
	}
	if q.deleteAllProjectRequirementStatByStatIdStmt, err = db.PrepareContext(ctx, deleteAllProjectRequirementStatByStatId); err != nil {
		return nil, fmt.Errorf("error preparing query DeleteAllProjectRequirementStatByStatId: %w", err)
	}
	if q.deleteAllProjectRequirementStatsStmt, err = db.PrepareContext(ctx, deleteAllProjectRequirementStats); err != nil {
		return nil, fmt.Errorf("error preparing query DeleteAllProjectRequirementStats: %w", err)
	}
	if q.deleteAllProjectRequirementsStmt, err = db.PrepareContext(ctx, deleteAllProjectRequirements); err != nil {
		return nil, fmt.Errorf("error preparing query DeleteAllProjectRequirements: %w", err)
	}
	if q.deleteAllScopeItemsStmt, err = db.PrepareContext(ctx, deleteAllScopeItems); err != nil {
		return nil, fmt.Errorf("error preparing query DeleteAllScopeItems: %w", err)
	}
	if q.deleteAllScopeMembersStmt, err = db.PrepareContext(ctx, deleteAllScopeMembers); err != nil {
		return nil, fmt.Errorf("error preparing query DeleteAllScopeMembers: %w", err)
	}
	if q.deleteAllScopeProjectRequirementsStmt, err = db.PrepareContext(ctx, deleteAllScopeProjectRequirements); err != nil {
		return nil, fmt.Errorf("error preparing query DeleteAllScopeProjectRequirements: %w", err)
	}
	if q.deleteAllScopeProjectsStmt, err = db.PrepareContext(ctx, deleteAllScopeProjects); err != nil {
		return nil, fmt.Errorf("error preparing query DeleteAllScopeProjects: %w", err)
	}
	if q.deleteAllScopeSprintsStmt, err = db.PrepareContext(ctx, deleteAllScopeSprints); err != nil {
		return nil, fmt.Errorf("error preparing query DeleteAllScopeSprints: %w", err)
	}
	if q.deleteAllScopeStatsStmt, err = db.PrepareContext(ctx, deleteAllScopeStats); err != nil {
		return nil, fmt.Errorf("error preparing query DeleteAllScopeStats: %w", err)
	}
	if q.deleteAllSprintPartsStmt, err = db.PrepareContext(ctx, deleteAllSprintParts); err != nil {
		return nil, fmt.Errorf("error preparing query DeleteAllSprintParts: %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.deleteProjectRequirementStatStmt, err = db.PrepareContext(ctx, deleteProjectRequirementStat); err != nil {
		return nil, fmt.Errorf("error preparing query DeleteProjectRequirementStat: %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.deleteSprintStmt, err = db.PrepareContext(ctx, deleteSprint); err != nil {
		return nil, fmt.Errorf("error preparing query DeleteSprint: %w", err)
	}
	if q.deleteSprintPartStmt, err = db.PrepareContext(ctx, deleteSprintPart); err != nil {
		return nil, fmt.Errorf("error preparing query DeleteSprintPart: %w", err)
	}
	if q.deleteStatStmt, err = db.PrepareContext(ctx, deleteStat); err != nil {
		return nil, fmt.Errorf("error preparing query DeleteStat: %w", err)
	}
	if q.deleteTagStmt, err = db.PrepareContext(ctx, deleteTag); err != nil {
		return nil, fmt.Errorf("error preparing query DeleteTag: %w", err)
	}
	if q.deleteTagByObjectStmt, err = db.PrepareContext(ctx, deleteTagByObject); err != nil {
		return nil, fmt.Errorf("error preparing query DeleteTagByObject: %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.getScopeStmt, err = db.PrepareContext(ctx, getScope); err != nil {
		return nil, fmt.Errorf("error preparing query GetScope: %w", err)
	}
	if q.getSprintStmt, err = db.PrepareContext(ctx, getSprint); err != nil {
		return nil, fmt.Errorf("error preparing query GetSprint: %w", err)
	}
	if q.getStatStmt, err = db.PrepareContext(ctx, getStat); err != nil {
		return nil, fmt.Errorf("error preparing query GetStat: %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.insertSprintStmt, err = db.PrepareContext(ctx, insertSprint); err != nil {
		return nil, fmt.Errorf("error preparing query InsertSprint: %w", err)
	}
	if q.insertStatStmt, err = db.PrepareContext(ctx, insertStat); err != nil {
		return nil, fmt.Errorf("error preparing query InsertStat: %w", err)
	}
	if q.insertTagStmt, err = db.PrepareContext(ctx, insertTag); err != nil {
		return nil, fmt.Errorf("error preparing query InsertTag: %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.listProjectRequirementsStmt, err = db.PrepareContext(ctx, listProjectRequirements); err != nil {
		return nil, fmt.Errorf("error preparing query ListProjectRequirements: %w", err)
	}
	if q.listProjectRequirementsByScopeIDStmt, err = db.PrepareContext(ctx, listProjectRequirementsByScopeID); err != nil {
		return nil, fmt.Errorf("error preparing query ListProjectRequirementsByScopeID: %w", err)
	}
	if q.listProjectRequirementsStatsStmt, err = db.PrepareContext(ctx, listProjectRequirementsStats); err != nil {
		return nil, fmt.Errorf("error preparing query ListProjectRequirementsStats: %w", err)
	}
	if q.listProjectRequirementsStatsByScopeIDStmt, err = db.PrepareContext(ctx, listProjectRequirementsStatsByScopeID); err != nil {
		return nil, fmt.Errorf("error preparing query ListProjectRequirementsStatsByScopeID: %w", err)
	}
	if q.listProjectsStmt, err = db.PrepareContext(ctx, listProjects); err != nil {
		return nil, fmt.Errorf("error preparing query ListProjects: %w", err)
	}
	if q.listScopeMembersStmt, err = db.PrepareContext(ctx, listScopeMembers); err != nil {
		return nil, fmt.Errorf("error preparing query ListScopeMembers: %w", err)
	}
	if q.listScopeMembersMultiStmt, err = db.PrepareContext(ctx, listScopeMembersMulti); err != nil {
		return nil, fmt.Errorf("error preparing query ListScopeMembersMulti: %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.listSprintPartsStmt, err = db.PrepareContext(ctx, listSprintParts); err != nil {
		return nil, fmt.Errorf("error preparing query ListSprintParts: %w", err)
	}
	if q.listSprintsAtStmt, err = db.PrepareContext(ctx, listSprintsAt); err != nil {
		return nil, fmt.Errorf("error preparing query ListSprintsAt: %w", err)
	}
	if q.listSprintsBetweenStmt, err = db.PrepareContext(ctx, listSprintsBetween); err != nil {
		return nil, fmt.Errorf("error preparing query ListSprintsBetween: %w", err)
	}
	if q.listStatsStmt, err = db.PrepareContext(ctx, listStats); err != nil {
		return nil, fmt.Errorf("error preparing query ListStats: %w", err)
	}
	if q.listTagsByObjectStmt, err = db.PrepareContext(ctx, listTagsByObject); err != nil {
		return nil, fmt.Errorf("error preparing query ListTagsByObject: %w", err)
	}
	if q.replaceItemStatProgressStmt, err = db.PrepareContext(ctx, replaceItemStatProgress); err != nil {
		return nil, fmt.Errorf("error preparing query ReplaceItemStatProgress: %w", err)
	}
	if q.replaceProjectRequirementStatStmt, err = db.PrepareContext(ctx, replaceProjectRequirementStat); err != nil {
		return nil, fmt.Errorf("error preparing query ReplaceProjectRequirementStat: %w", err)
	}
	if q.replaceScopeMemberStmt, err = db.PrepareContext(ctx, replaceScopeMember); err != nil {
		return nil, fmt.Errorf("error preparing query ReplaceScopeMember: %w", err)
	}
	if q.replaceSprintPartStmt, err = db.PrepareContext(ctx, replaceSprintPart); err != nil {
		return nil, fmt.Errorf("error preparing query ReplaceSprintPart: %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.updateSprintStmt, err = db.PrepareContext(ctx, updateSprint); err != nil {
		return nil, fmt.Errorf("error preparing query UpdateSprint: %w", err)
	}
	if q.updateStatStmt, err = db.PrepareContext(ctx, updateStat); err != nil {
		return nil, fmt.Errorf("error preparing query UpdateStat: %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.clearItemStatProgressByStatStmt != nil {
		if cerr := q.clearItemStatProgressByStatStmt.Close(); cerr != nil {
			err = fmt.Errorf("error closing clearItemStatProgressByStatStmt: %w", cerr)
		}
	}
	if q.clearProjectRequirementStatsByStatStmt != nil {
		if cerr := q.clearProjectRequirementStatsByStatStmt.Close(); cerr != nil {
			err = fmt.Errorf("error closing clearProjectRequirementStatsByStatStmt: %w", cerr)
		}
	}
	if q.deleteAllItemStatProgressByStatIdStmt != nil {
		if cerr := q.deleteAllItemStatProgressByStatIdStmt.Close(); cerr != nil {
			err = fmt.Errorf("error closing deleteAllItemStatProgressByStatIdStmt: %w", cerr)
		}
	}
	if q.deleteAllProjectRequirementStatByStatIdStmt != nil {
		if cerr := q.deleteAllProjectRequirementStatByStatIdStmt.Close(); cerr != nil {
			err = fmt.Errorf("error closing deleteAllProjectRequirementStatByStatIdStmt: %w", cerr)
		}
	}
	if q.deleteAllProjectRequirementStatsStmt != nil {
		if cerr := q.deleteAllProjectRequirementStatsStmt.Close(); cerr != nil {
			err = fmt.Errorf("error closing deleteAllProjectRequirementStatsStmt: %w", cerr)
		}
	}
	if q.deleteAllProjectRequirementsStmt != nil {
		if cerr := q.deleteAllProjectRequirementsStmt.Close(); cerr != nil {
			err = fmt.Errorf("error closing deleteAllProjectRequirementsStmt: %w", cerr)
		}
	}
	if q.deleteAllScopeItemsStmt != nil {
		if cerr := q.deleteAllScopeItemsStmt.Close(); cerr != nil {
			err = fmt.Errorf("error closing deleteAllScopeItemsStmt: %w", cerr)
		}
	}
	if q.deleteAllScopeMembersStmt != nil {
		if cerr := q.deleteAllScopeMembersStmt.Close(); cerr != nil {
			err = fmt.Errorf("error closing deleteAllScopeMembersStmt: %w", cerr)
		}
	}
	if q.deleteAllScopeProjectRequirementsStmt != nil {
		if cerr := q.deleteAllScopeProjectRequirementsStmt.Close(); cerr != nil {
			err = fmt.Errorf("error closing deleteAllScopeProjectRequirementsStmt: %w", cerr)
		}
	}
	if q.deleteAllScopeProjectsStmt != nil {
		if cerr := q.deleteAllScopeProjectsStmt.Close(); cerr != nil {
			err = fmt.Errorf("error closing deleteAllScopeProjectsStmt: %w", cerr)
		}
	}
	if q.deleteAllScopeSprintsStmt != nil {
		if cerr := q.deleteAllScopeSprintsStmt.Close(); cerr != nil {
			err = fmt.Errorf("error closing deleteAllScopeSprintsStmt: %w", cerr)
		}
	}
	if q.deleteAllScopeStatsStmt != nil {
		if cerr := q.deleteAllScopeStatsStmt.Close(); cerr != nil {
			err = fmt.Errorf("error closing deleteAllScopeStatsStmt: %w", cerr)
		}
	}
	if q.deleteAllSprintPartsStmt != nil {
		if cerr := q.deleteAllSprintPartsStmt.Close(); cerr != nil {
			err = fmt.Errorf("error closing deleteAllSprintPartsStmt: %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.deleteProjectRequirementStatStmt != nil {
		if cerr := q.deleteProjectRequirementStatStmt.Close(); cerr != nil {
			err = fmt.Errorf("error closing deleteProjectRequirementStatStmt: %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.deleteSprintStmt != nil {
		if cerr := q.deleteSprintStmt.Close(); cerr != nil {
			err = fmt.Errorf("error closing deleteSprintStmt: %w", cerr)
		}
	}
	if q.deleteSprintPartStmt != nil {
		if cerr := q.deleteSprintPartStmt.Close(); cerr != nil {
			err = fmt.Errorf("error closing deleteSprintPartStmt: %w", cerr)
		}
	}
	if q.deleteStatStmt != nil {
		if cerr := q.deleteStatStmt.Close(); cerr != nil {
			err = fmt.Errorf("error closing deleteStatStmt: %w", cerr)
		}
	}
	if q.deleteTagStmt != nil {
		if cerr := q.deleteTagStmt.Close(); cerr != nil {
			err = fmt.Errorf("error closing deleteTagStmt: %w", cerr)
		}
	}
	if q.deleteTagByObjectStmt != nil {
		if cerr := q.deleteTagByObjectStmt.Close(); cerr != nil {
			err = fmt.Errorf("error closing deleteTagByObjectStmt: %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.getScopeStmt != nil {
		if cerr := q.getScopeStmt.Close(); cerr != nil {
			err = fmt.Errorf("error closing getScopeStmt: %w", cerr)
		}
	}
	if q.getSprintStmt != nil {
		if cerr := q.getSprintStmt.Close(); cerr != nil {
			err = fmt.Errorf("error closing getSprintStmt: %w", cerr)
		}
	}
	if q.getStatStmt != nil {
		if cerr := q.getStatStmt.Close(); cerr != nil {
			err = fmt.Errorf("error closing getStatStmt: %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.insertSprintStmt != nil {
		if cerr := q.insertSprintStmt.Close(); cerr != nil {
			err = fmt.Errorf("error closing insertSprintStmt: %w", cerr)
		}
	}
	if q.insertStatStmt != nil {
		if cerr := q.insertStatStmt.Close(); cerr != nil {
			err = fmt.Errorf("error closing insertStatStmt: %w", cerr)
		}
	}
	if q.insertTagStmt != nil {
		if cerr := q.insertTagStmt.Close(); cerr != nil {
			err = fmt.Errorf("error closing insertTagStmt: %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.listProjectRequirementsStmt != nil {
		if cerr := q.listProjectRequirementsStmt.Close(); cerr != nil {
			err = fmt.Errorf("error closing listProjectRequirementsStmt: %w", cerr)
		}
	}
	if q.listProjectRequirementsByScopeIDStmt != nil {
		if cerr := q.listProjectRequirementsByScopeIDStmt.Close(); cerr != nil {
			err = fmt.Errorf("error closing listProjectRequirementsByScopeIDStmt: %w", cerr)
		}
	}
	if q.listProjectRequirementsStatsStmt != nil {
		if cerr := q.listProjectRequirementsStatsStmt.Close(); cerr != nil {
			err = fmt.Errorf("error closing listProjectRequirementsStatsStmt: %w", cerr)
		}
	}
	if q.listProjectRequirementsStatsByScopeIDStmt != nil {
		if cerr := q.listProjectRequirementsStatsByScopeIDStmt.Close(); cerr != nil {
			err = fmt.Errorf("error closing listProjectRequirementsStatsByScopeIDStmt: %w", cerr)
		}
	}
	if q.listProjectsStmt != nil {
		if cerr := q.listProjectsStmt.Close(); cerr != nil {
			err = fmt.Errorf("error closing listProjectsStmt: %w", cerr)
		}
	}
	if q.listScopeMembersStmt != nil {
		if cerr := q.listScopeMembersStmt.Close(); cerr != nil {
			err = fmt.Errorf("error closing listScopeMembersStmt: %w", cerr)
		}
	}
	if q.listScopeMembersMultiStmt != nil {
		if cerr := q.listScopeMembersMultiStmt.Close(); cerr != nil {
			err = fmt.Errorf("error closing listScopeMembersMultiStmt: %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.listSprintPartsStmt != nil {
		if cerr := q.listSprintPartsStmt.Close(); cerr != nil {
			err = fmt.Errorf("error closing listSprintPartsStmt: %w", cerr)
		}
	}
	if q.listSprintsAtStmt != nil {
		if cerr := q.listSprintsAtStmt.Close(); cerr != nil {
			err = fmt.Errorf("error closing listSprintsAtStmt: %w", cerr)
		}
	}
	if q.listSprintsBetweenStmt != nil {
		if cerr := q.listSprintsBetweenStmt.Close(); cerr != nil {
			err = fmt.Errorf("error closing listSprintsBetweenStmt: %w", cerr)
		}
	}
	if q.listStatsStmt != nil {
		if cerr := q.listStatsStmt.Close(); cerr != nil {
			err = fmt.Errorf("error closing listStatsStmt: %w", cerr)
		}
	}
	if q.listTagsByObjectStmt != nil {
		if cerr := q.listTagsByObjectStmt.Close(); cerr != nil {
			err = fmt.Errorf("error closing listTagsByObjectStmt: %w", cerr)
		}
	}
	if q.replaceItemStatProgressStmt != nil {
		if cerr := q.replaceItemStatProgressStmt.Close(); cerr != nil {
			err = fmt.Errorf("error closing replaceItemStatProgressStmt: %w", cerr)
		}
	}
	if q.replaceProjectRequirementStatStmt != nil {
		if cerr := q.replaceProjectRequirementStatStmt.Close(); cerr != nil {
			err = fmt.Errorf("error closing replaceProjectRequirementStatStmt: %w", cerr)
		}
	}
	if q.replaceScopeMemberStmt != nil {
		if cerr := q.replaceScopeMemberStmt.Close(); cerr != nil {
			err = fmt.Errorf("error closing replaceScopeMemberStmt: %w", cerr)
		}
	}
	if q.replaceSprintPartStmt != nil {
		if cerr := q.replaceSprintPartStmt.Close(); cerr != nil {
			err = fmt.Errorf("error closing replaceSprintPartStmt: %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.updateSprintStmt != nil {
		if cerr := q.updateSprintStmt.Close(); cerr != nil {
			err = fmt.Errorf("error closing updateSprintStmt: %w", cerr)
		}
	}
	if q.updateStatStmt != nil {
		if cerr := q.updateStatStmt.Close(); cerr != nil {
			err = fmt.Errorf("error closing updateStatStmt: %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
	tx                                          *sql.Tx
	clearItemProjectRequirementStmt             *sql.Stmt
	clearItemStatProgressStmt                   *sql.Stmt
	clearItemStatProgressByStatStmt             *sql.Stmt
	clearProjectRequirementStatsByStatStmt      *sql.Stmt
	deleteAllItemStatProgressByStatIdStmt       *sql.Stmt
	deleteAllProjectRequirementStatByStatIdStmt *sql.Stmt
	deleteAllProjectRequirementStatsStmt        *sql.Stmt
	deleteAllProjectRequirementsStmt            *sql.Stmt
	deleteAllScopeItemsStmt                     *sql.Stmt
	deleteAllScopeMembersStmt                   *sql.Stmt
	deleteAllScopeProjectRequirementsStmt       *sql.Stmt
	deleteAllScopeProjectsStmt                  *sql.Stmt
	deleteAllScopeSprintsStmt                   *sql.Stmt
	deleteAllScopeStatsStmt                     *sql.Stmt
	deleteAllSprintPartsStmt                    *sql.Stmt
	deleteItemStmt                              *sql.Stmt
	deleteItemForRequirementStmt                *sql.Stmt
	deleteItemStatProgressStmt                  *sql.Stmt
	deleteProjectStmt                           *sql.Stmt
	deleteProjectRequirementStmt                *sql.Stmt
	deleteProjectRequirementStatStmt            *sql.Stmt
	deleteScopeStmt                             *sql.Stmt
	deleteScopeMemberStmt                       *sql.Stmt
	deleteSprintStmt                            *sql.Stmt
	deleteSprintPartStmt                        *sql.Stmt
	deleteStatStmt                              *sql.Stmt
	deleteTagStmt                               *sql.Stmt
	deleteTagByObjectStmt                       *sql.Stmt
	getItemStmt                                 *sql.Stmt
	getItemStatProgressBetweenStmt              *sql.Stmt
	getProjectStmt                              *sql.Stmt
	getScopeStmt                                *sql.Stmt
	getSprintStmt                               *sql.Stmt
	getStatStmt                                 *sql.Stmt
	insertItemStmt                              *sql.Stmt
	insertProjectStmt                           *sql.Stmt
	insertProjectRequirementStmt                *sql.Stmt
	insertScopeStmt                             *sql.Stmt
	insertSprintStmt                            *sql.Stmt
	insertStatStmt                              *sql.Stmt
	insertTagStmt                               *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
	listProjectRequirementsStmt                 *sql.Stmt
	listProjectRequirementsByScopeIDStmt        *sql.Stmt
	listProjectRequirementsStatsStmt            *sql.Stmt
	listProjectRequirementsStatsByScopeIDStmt   *sql.Stmt
	listProjectsStmt                            *sql.Stmt
	listScopeMembersStmt                        *sql.Stmt
	listScopeMembersMultiStmt                   *sql.Stmt
	listScopesStmt                              *sql.Stmt
	listScopesByUserStmt                        *sql.Stmt
	listSprintPartsStmt                         *sql.Stmt
	listSprintsAtStmt                           *sql.Stmt
	listSprintsBetweenStmt                      *sql.Stmt
	listStatsStmt                               *sql.Stmt
	listTagsByObjectStmt                        *sql.Stmt
	replaceItemStatProgressStmt                 *sql.Stmt
	replaceProjectRequirementStatStmt           *sql.Stmt
	replaceScopeMemberStmt                      *sql.Stmt
	replaceSprintPartStmt                       *sql.Stmt
	updateItemStmt                              *sql.Stmt
	updateProjectStmt                           *sql.Stmt
	updateProjectRequirementStmt                *sql.Stmt
	updateScopeStmt                             *sql.Stmt
	updateSprintStmt                            *sql.Stmt
	updateStatStmt                              *sql.Stmt
}

func (q *Queries) WithTx(tx *sql.Tx) *Queries {
	return &Queries{
		db:                                     tx,
		tx:                                     tx,
		clearItemProjectRequirementStmt:        q.clearItemProjectRequirementStmt,
		clearItemStatProgressStmt:              q.clearItemStatProgressStmt,
		clearItemStatProgressByStatStmt:        q.clearItemStatProgressByStatStmt,
		clearProjectRequirementStatsByStatStmt: q.clearProjectRequirementStatsByStatStmt,
		deleteAllItemStatProgressByStatIdStmt:  q.deleteAllItemStatProgressByStatIdStmt,
		deleteAllProjectRequirementStatByStatIdStmt: q.deleteAllProjectRequirementStatByStatIdStmt,
		deleteAllProjectRequirementStatsStmt:        q.deleteAllProjectRequirementStatsStmt,
		deleteAllProjectRequirementsStmt:            q.deleteAllProjectRequirementsStmt,
		deleteAllScopeItemsStmt:                     q.deleteAllScopeItemsStmt,
		deleteAllScopeMembersStmt:                   q.deleteAllScopeMembersStmt,
		deleteAllScopeProjectRequirementsStmt:       q.deleteAllScopeProjectRequirementsStmt,
		deleteAllScopeProjectsStmt:                  q.deleteAllScopeProjectsStmt,
		deleteAllScopeSprintsStmt:                   q.deleteAllScopeSprintsStmt,
		deleteAllScopeStatsStmt:                     q.deleteAllScopeStatsStmt,
		deleteAllSprintPartsStmt:                    q.deleteAllSprintPartsStmt,
		deleteItemStmt:                              q.deleteItemStmt,
		deleteItemForRequirementStmt:                q.deleteItemForRequirementStmt,
		deleteItemStatProgressStmt:                  q.deleteItemStatProgressStmt,
		deleteProjectStmt:                           q.deleteProjectStmt,
		deleteProjectRequirementStmt:                q.deleteProjectRequirementStmt,
		deleteProjectRequirementStatStmt:            q.deleteProjectRequirementStatStmt,
		deleteScopeStmt:                             q.deleteScopeStmt,
		deleteScopeMemberStmt:                       q.deleteScopeMemberStmt,
		deleteSprintStmt:                            q.deleteSprintStmt,
		deleteSprintPartStmt:                        q.deleteSprintPartStmt,
		deleteStatStmt:                              q.deleteStatStmt,
		deleteTagStmt:                               q.deleteTagStmt,
		deleteTagByObjectStmt:                       q.deleteTagByObjectStmt,
		getItemStmt:                                 q.getItemStmt,
		getItemStatProgressBetweenStmt:              q.getItemStatProgressBetweenStmt,
		getProjectStmt:                              q.getProjectStmt,
		getScopeStmt:                                q.getScopeStmt,
		getSprintStmt:                               q.getSprintStmt,
		getStatStmt:                                 q.getStatStmt,
		insertItemStmt:                              q.insertItemStmt,
		insertProjectStmt:                           q.insertProjectStmt,
		insertProjectRequirementStmt:                q.insertProjectRequirementStmt,
		insertScopeStmt:                             q.insertScopeStmt,
		insertSprintStmt:                            q.insertSprintStmt,
		insertStatStmt:                              q.insertStatStmt,
		insertTagStmt:                               q.insertTagStmt,
		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,
		listProjectRequirementsStmt:                 q.listProjectRequirementsStmt,
		listProjectRequirementsByScopeIDStmt:        q.listProjectRequirementsByScopeIDStmt,
		listProjectRequirementsStatsStmt:            q.listProjectRequirementsStatsStmt,
		listProjectRequirementsStatsByScopeIDStmt:   q.listProjectRequirementsStatsByScopeIDStmt,
		listProjectsStmt:                            q.listProjectsStmt,
		listScopeMembersStmt:                        q.listScopeMembersStmt,
		listScopeMembersMultiStmt:                   q.listScopeMembersMultiStmt,
		listScopesStmt:                              q.listScopesStmt,
		listScopesByUserStmt:                        q.listScopesByUserStmt,
		listSprintPartsStmt:                         q.listSprintPartsStmt,
		listSprintsAtStmt:                           q.listSprintsAtStmt,
		listSprintsBetweenStmt:                      q.listSprintsBetweenStmt,
		listStatsStmt:                               q.listStatsStmt,
		listTagsByObjectStmt:                        q.listTagsByObjectStmt,
		replaceItemStatProgressStmt:                 q.replaceItemStatProgressStmt,
		replaceProjectRequirementStatStmt:           q.replaceProjectRequirementStatStmt,
		replaceScopeMemberStmt:                      q.replaceScopeMemberStmt,
		replaceSprintPartStmt:                       q.replaceSprintPartStmt,
		updateItemStmt:                              q.updateItemStmt,
		updateProjectStmt:                           q.updateProjectStmt,
		updateProjectRequirementStmt:                q.updateProjectRequirementStmt,
		updateScopeStmt:                             q.updateScopeStmt,
		updateSprintStmt:                            q.updateSprintStmt,
		updateStatStmt:                              q.updateStatStmt,
	}
}