internal/postgres: rename variable version

Various uses of the variable version is renamed to requestedVersion and
resolvedVersion for clarity.

Change-Id: I9dc4987d605631549497261b18f165fc9c157508
Reviewed-on: https://go-review.googlesource.com/c/pkgsite/+/256178
Trust: Julie Qiu <julie@golang.org>
Run-TryBot: Julie Qiu <julie@golang.org>
Reviewed-by: Jonathan Amsterdam <jba@google.com>
TryBot-Result: kokoro <noreply+kokoro@google.com>

9 files changed, 71 insertions, 71 deletions

diff --git a/internal/postgres/details.go b/internal/postgres/details.go
index 23a898c3..7078fd85 100644
--- a/internal/postgres/details.go
+++ b/internal/postgres/details.go
@@ -64,7 +64,7 @@ func (db *DB) GetNestedModules(ctx context.Context, modulePath string) (_ []*int
 // LegacyGetPackagesInModule returns packages contained in the module version
 // specified by modulePath and version. The returned packages will be sorted
 // by their package path.
-func (db *DB) LegacyGetPackagesInModule(ctx context.Context, modulePath, version string) (_ []*internal.LegacyPackage, err error) {
+func (db *DB) LegacyGetPackagesInModule(ctx context.Context, modulePath, resolvedVersion string) (_ []*internal.LegacyPackage, err error) {
 	query := `SELECT
 		path,
 		name,
@@ -105,8 +105,8 @@ func (db *DB) LegacyGetPackagesInModule(ctx context.Context, modulePath, version
 		return nil
 	}
 
-	if err := db.db.RunQuery(ctx, query, collect, modulePath, version); err != nil {
-		return nil, fmt.Errorf("DB.LegacyGetPackagesInModule(ctx, %q, %q): %w", modulePath, version, err)
+	if err := db.db.RunQuery(ctx, query, collect, modulePath, resolvedVersion); err != nil {
+		return nil, fmt.Errorf("DB.LegacyGetPackagesInModule(ctx, %q, %q): %w", modulePath, resolvedVersion, err)
 	}
 	for _, p := range packages {
 		if db.bypassLicenseCheck {
@@ -123,10 +123,10 @@ func (db *DB) LegacyGetPackagesInModule(ctx context.Context, modulePath, version
 //
 // The returned error may be checked with derrors.IsInvalidArgument to
 // determine if it resulted from an invalid package path or version.
-func (db *DB) LegacyGetImports(ctx context.Context, pkgPath, modulePath, version string) (paths []string, err error) {
-	defer derrors.Wrap(&err, "DB.LegacyGetImports(ctx, %q, %q, %q)", pkgPath, modulePath, version)
+func (db *DB) LegacyGetImports(ctx context.Context, pkgPath, modulePath, resolvedVersion string) (paths []string, err error) {
+	defer derrors.Wrap(&err, "DB.LegacyGetImports(ctx, %q, %q, %q)", pkgPath, modulePath, resolvedVersion)
 
-	if pkgPath == "" || version == "" || modulePath == "" {
+	if pkgPath == "" || resolvedVersion == "" || modulePath == "" {
 		return nil, fmt.Errorf("pkgPath, modulePath and version must all be non-empty: %w", derrors.InvalidArgument)
 	}
 
@@ -150,7 +150,7 @@ func (db *DB) LegacyGetImports(ctx context.Context, pkgPath, modulePath, version
 		imports = append(imports, toPath)
 		return nil
 	}
-	if err := db.db.RunQuery(ctx, query, collect, pkgPath, version, modulePath); err != nil {
+	if err := db.db.RunQuery(ctx, query, collect, pkgPath, resolvedVersion, modulePath); err != nil {
 		return nil, err
 	}
 	return imports, nil
@@ -197,8 +197,8 @@ func (db *DB) GetImportedBy(ctx context.Context, pkgPath, modulePath string, lim
 
 // GetModuleInfo fetches a module version from the database with the primary key
 // (module_path, version).
-func (db *DB) GetModuleInfo(ctx context.Context, modulePath, version string) (_ *internal.ModuleInfo, err error) {
-	defer derrors.Wrap(&err, "GetModuleInfo(ctx, %q, %q)", modulePath, version)
+func (db *DB) GetModuleInfo(ctx context.Context, modulePath, resolvedVersion string) (_ *internal.ModuleInfo, err error) {
+	defer derrors.Wrap(&err, "GetModuleInfo(ctx, %q, %q)", modulePath, resolvedVersion)
 
 	query := `
 		SELECT
@@ -214,7 +214,7 @@ func (db *DB) GetModuleInfo(ctx context.Context, modulePath, version string) (_
 			module_path = $1
 			AND version = $2;`
 
-	row := db.db.QueryRow(ctx, query, modulePath, version)
+	row := db.db.QueryRow(ctx, query, modulePath, resolvedVersion)
 	mi, err := scanModuleInfo(row.Scan)
 	if err == sql.ErrNoRows {
 		return nil, derrors.NotFound
@@ -227,8 +227,8 @@ func (db *DB) GetModuleInfo(ctx context.Context, modulePath, version string) (_
 
 // LegacyGetModuleInfo fetches a module version from the database with the primary key
 // (module_path, version).
-func (db *DB) LegacyGetModuleInfo(ctx context.Context, modulePath string, version string) (_ *internal.LegacyModuleInfo, err error) {
-	defer derrors.Wrap(&err, "LegacyGetModuleInfo(ctx, %q, %q)", modulePath, version)
+func (db *DB) LegacyGetModuleInfo(ctx context.Context, modulePath string, requestedVersion string) (_ *internal.LegacyModuleInfo, err error) {
+	defer derrors.Wrap(&err, "LegacyGetModuleInfo(ctx, %q, %q)", modulePath, requestedVersion)
 
 	query := `
 		SELECT
@@ -244,13 +244,13 @@ func (db *DB) LegacyGetModuleInfo(ctx context.Context, modulePath string, versio
 			modules m`
 
 	args := []interface{}{modulePath}
-	if version == internal.LatestVersion {
+	if requestedVersion == internal.LatestVersion {
 		query += fmt.Sprintf(`
 			WHERE m.module_path = $1 %s LIMIT 1;`, orderByLatest)
 	} else {
 		query += `
 			WHERE m.module_path = $1 AND m.version = $2;`
-		args = append(args, version)
+		args = append(args, requestedVersion)
 	}
 
 	var mi internal.LegacyModuleInfo
@@ -259,7 +259,7 @@ func (db *DB) LegacyGetModuleInfo(ctx context.Context, modulePath string, versio
 		database.NullIsEmpty(&mi.LegacyReadmeFilePath), database.NullIsEmpty(&mi.LegacyReadmeContents),
 		jsonbScanner{&mi.SourceInfo}, &mi.IsRedistributable, &mi.HasGoMod); err != nil {
 		if err == sql.ErrNoRows {
-			return nil, fmt.Errorf("module version %s@%s: %w", modulePath, version, derrors.NotFound)
+			return nil, fmt.Errorf("module version %s@%s: %w", modulePath, requestedVersion, derrors.NotFound)
 		}
 		return nil, fmt.Errorf("row.Scan(): %v", err)
 	}
diff --git a/internal/postgres/insert_module.go b/internal/postgres/insert_module.go
index 4b7529c3..e7ed5b1b 100644
--- a/internal/postgres/insert_module.go
+++ b/internal/postgres/insert_module.go
@@ -561,7 +561,7 @@ func isIncompatible(version string) bool {
 }
 
 // isLatestVersion reports whether version is the latest version of the module.
-func isLatestVersion(ctx context.Context, db *database.DB, modulePath, version string) (_ bool, err error) {
+func isLatestVersion(ctx context.Context, db *database.DB, modulePath, resolvedVersion string) (_ bool, err error) {
 	defer derrors.Wrap(&err, "isLatestVersion(ctx, tx, %q)", modulePath)
 
 	query := fmt.Sprintf(`
@@ -577,7 +577,7 @@ func isLatestVersion(ctx context.Context, db *database.DB, modulePath, version s
 		}
 		return false, err
 	}
-	return version == v, nil
+	return resolvedVersion == v, nil
 }
 
 // validateModule checks that fields needed to insert a module into the database
@@ -687,17 +687,17 @@ func (db *DB) comparePaths(ctx context.Context, m *internal.Module) (err error)
 }
 
 // DeleteModule deletes a Version from the database.
-func (db *DB) DeleteModule(ctx context.Context, modulePath, version string) (err error) {
-	defer derrors.Wrap(&err, "DeleteModule(ctx, db, %q, %q)", modulePath, version)
+func (db *DB) DeleteModule(ctx context.Context, modulePath, resolvedVersion string) (err error) {
+	defer derrors.Wrap(&err, "DeleteModule(ctx, db, %q, %q)", modulePath, resolvedVersion)
 	return db.db.Transact(ctx, sql.LevelDefault, func(tx *database.DB) error {
 		// We only need to delete from the modules table. Thanks to ON DELETE
 		// CASCADE constraints, that will trigger deletions from all other tables.
 		const stmt = `DELETE FROM modules WHERE module_path=$1 AND version=$2`
-		if _, err := tx.Exec(ctx, stmt, modulePath, version); err != nil {
+		if _, err := tx.Exec(ctx, stmt, modulePath, resolvedVersion); err != nil {
 			return err
 		}
 
-		if _, err = tx.Exec(ctx, `DELETE FROM version_map WHERE module_path = $1 AND resolved_version = $2`, modulePath, version); err != nil {
+		if _, err = tx.Exec(ctx, `DELETE FROM version_map WHERE module_path = $1 AND resolved_version = $2`, modulePath, resolvedVersion); err != nil {
 			return err
 		}
 
diff --git a/internal/postgres/legacy_directory.go b/internal/postgres/legacy_directory.go
index 019d8aeb..ef02a458 100644
--- a/internal/postgres/legacy_directory.go
+++ b/internal/postgres/legacy_directory.go
@@ -53,10 +53,10 @@ import (
 //
 // It will not match on:
 // golang.org/x/tools/g
-func (db *DB) LegacyGetDirectory(ctx context.Context, dirPath, modulePath, version string, fields internal.FieldSet) (_ *internal.LegacyDirectory, err error) {
-	defer derrors.Wrap(&err, "DB.LegacyGetDirectory(ctx, %q, %q, %q)", dirPath, modulePath, version)
+func (db *DB) LegacyGetDirectory(ctx context.Context, dirPath, modulePath, requestedVersion string, fields internal.FieldSet) (_ *internal.LegacyDirectory, err error) {
+	defer derrors.Wrap(&err, "DB.LegacyGetDirectory(ctx, %q, %q, %q)", dirPath, modulePath, requestedVersion)
 
-	if dirPath == "" || modulePath == "" || version == "" {
+	if dirPath == "" || modulePath == "" || requestedVersion == "" {
 		return nil, fmt.Errorf("none of pkgPath, modulePath, or version can be empty: %w", derrors.InvalidArgument)
 	}
 
@@ -65,9 +65,9 @@ func (db *DB) LegacyGetDirectory(ctx context.Context, dirPath, modulePath, versi
 		args  []interface{}
 	)
 	if modulePath == internal.UnknownModulePath || modulePath == stdlib.ModulePath {
-		query, args = directoryQueryWithoutModulePath(dirPath, version, fields)
+		query, args = directoryQueryWithoutModulePath(dirPath, requestedVersion, fields)
 	} else {
-		query, args = directoryQueryWithModulePath(dirPath, modulePath, version, fields)
+		query, args = directoryQueryWithModulePath(dirPath, modulePath, requestedVersion, fields)
 	}
 
 	var (
@@ -249,8 +249,8 @@ func directoryQueryWithoutModulePath(dirPath, version string, fields internal.Fi
 
 // directoryQueryWithoutModulePath returns the query and args needed to fetch a
 // directory when a module path is provided.
-func directoryQueryWithModulePath(dirPath, modulePath, version string, fields internal.FieldSet) (string, []interface{}) {
-	if version == internal.LatestVersion {
+func directoryQueryWithModulePath(dirPath, modulePath, requestedVersion string, fields internal.FieldSet) (string, []interface{}) {
+	if requestedVersion == internal.LatestVersion {
 		// dirPath and modulePath are specified, so get the latest version of
 		// the package in the specified module.
 		return fmt.Sprintf(`
@@ -294,5 +294,5 @@ func directoryQueryWithModulePath(dirPath, modulePath, version string, fields in
 			WHERE
 				tsv_parent_directories @@ $1::tsquery
 				AND p.module_path = $2
-				AND p.version = $3;`, directoryColumns(fields)), []interface{}{dirPath, modulePath, version}
+				AND p.version = $3;`, directoryColumns(fields)), []interface{}{dirPath, modulePath, requestedVersion}
 }
diff --git a/internal/postgres/licenses.go b/internal/postgres/licenses.go
index b95970d5..6ca9d14f 100644
--- a/internal/postgres/licenses.go
+++ b/internal/postgres/licenses.go
@@ -93,10 +93,10 @@ func (db *DB) getLicenses(ctx context.Context, fullPath, modulePath string, path
 // LegacyGetModuleLicenses returns all licenses associated with the given module path and
 // version. These are the top-level licenses in the module zip file.
 // It returns an InvalidArgument error if the module path or version is invalid.
-func (db *DB) LegacyGetModuleLicenses(ctx context.Context, modulePath, version string) (_ []*licenses.License, err error) {
-	defer derrors.Wrap(&err, "LegacyGetModuleLicenses(ctx, %q, %q)", modulePath, version)
+func (db *DB) LegacyGetModuleLicenses(ctx context.Context, modulePath, resolvedVersion string) (_ []*licenses.License, err error) {
+	defer derrors.Wrap(&err, "LegacyGetModuleLicenses(ctx, %q, %q)", modulePath, resolvedVersion)
 
-	if modulePath == "" || version == "" {
+	if modulePath == "" || resolvedVersion == "" {
 		return nil, fmt.Errorf("neither modulePath nor version can be empty: %w", derrors.InvalidArgument)
 	}
 	query := `
@@ -107,7 +107,7 @@ func (db *DB) LegacyGetModuleLicenses(ctx context.Context, modulePath, version s
 	WHERE
 		module_path = $1 AND version = $2 AND position('/' in file_path) = 0
     `
-	rows, err := db.db.Query(ctx, query, modulePath, version)
+	rows, err := db.db.Query(ctx, query, modulePath, resolvedVersion)
 	if err != nil {
 		return nil, err
 	}
@@ -118,10 +118,10 @@ func (db *DB) LegacyGetModuleLicenses(ctx context.Context, modulePath, version s
 // LegacyGetPackageLicenses returns all licenses associated with the given package path and
 // version.
 // It returns an InvalidArgument error if the module path or version is invalid.
-func (db *DB) LegacyGetPackageLicenses(ctx context.Context, pkgPath, modulePath, version string) (_ []*licenses.License, err error) {
-	defer derrors.Wrap(&err, "LegacyGetPackageLicenses(ctx, %q, %q, %q)", pkgPath, modulePath, version)
+func (db *DB) LegacyGetPackageLicenses(ctx context.Context, pkgPath, modulePath, resolvedVersion string) (_ []*licenses.License, err error) {
+	defer derrors.Wrap(&err, "LegacyGetPackageLicenses(ctx, %q, %q, %q)", pkgPath, modulePath, resolvedVersion)
 
-	if pkgPath == "" || version == "" {
+	if pkgPath == "" || resolvedVersion == "" {
 		return nil, fmt.Errorf("neither pkgPath nor version can be empty: %w", derrors.InvalidArgument)
 	}
 	query := `
@@ -149,7 +149,7 @@ func (db *DB) LegacyGetPackageLicenses(ctx context.Context, pkgPath, modulePath,
 			AND p.version = l.version
 			AND p.license_file_path = l.file_path;`
 
-	rows, err := db.db.Query(ctx, query, pkgPath, modulePath, version)
+	rows, err := db.db.Query(ctx, query, pkgPath, modulePath, resolvedVersion)
 	if err != nil {
 		return nil, err
 	}
diff --git a/internal/postgres/package.go b/internal/postgres/package.go
index 65c07578..dd808c8f 100644
--- a/internal/postgres/package.go
+++ b/internal/postgres/package.go
@@ -41,9 +41,9 @@ import (
 // The returned error may be checked with
 // errors.Is(err, derrors.InvalidArgument) to determine if it was caused by an
 // invalid path or version.
-func (db *DB) LegacyGetPackage(ctx context.Context, pkgPath, modulePath, version string) (_ *internal.LegacyVersionedPackage, err error) {
-	defer derrors.Wrap(&err, "DB.LegacyGetPackage(ctx, %q, %q)", pkgPath, version)
-	if pkgPath == "" || modulePath == "" || version == "" {
+func (db *DB) LegacyGetPackage(ctx context.Context, pkgPath, modulePath, requestedVersion string) (_ *internal.LegacyVersionedPackage, err error) {
+	defer derrors.Wrap(&err, "DB.LegacyGetPackage(ctx, %q, %q)", pkgPath, requestedVersion)
+	if pkgPath == "" || modulePath == "" || requestedVersion == "" {
 		return nil, fmt.Errorf("none of pkgPath, modulePath, or version can be empty: %w", derrors.InvalidArgument)
 	}
 
@@ -77,7 +77,7 @@ func (db *DB) LegacyGetPackage(ctx context.Context, pkgPath, modulePath, version
 			AND m.version = p.version`
 
 	if modulePath == internal.UnknownModulePath || modulePath == stdlib.ModulePath {
-		if version == internal.LatestVersion {
+		if requestedVersion == internal.LatestVersion {
 			// Only pkgPath is specified, so get the latest version of the
 			// package found in any module.
 			query += fmt.Sprintf(`
@@ -96,9 +96,9 @@ func (db *DB) LegacyGetPackage(ctx context.Context, pkgPath, modulePath, version
 			ORDER BY
 				p.module_path DESC
 			LIMIT 1;`
-			args = append(args, version)
+			args = append(args, requestedVersion)
 		}
-	} else if version == internal.LatestVersion {
+	} else if requestedVersion == internal.LatestVersion {
 		// pkgPath and modulePath are specified, so get the latest version of
 		// the package in the specified module.
 		query += fmt.Sprintf(`
@@ -116,7 +116,7 @@ func (db *DB) LegacyGetPackage(ctx context.Context, pkgPath, modulePath, version
 				p.path = $1
 				AND p.version = $2
 				AND p.module_path = $3`
-		args = append(args, version, modulePath)
+		args = append(args, requestedVersion, modulePath)
 	}
 
 	var (
@@ -133,7 +133,7 @@ func (db *DB) LegacyGetPackage(ctx context.Context, pkgPath, modulePath, version
 		&pkg.HasGoMod)
 	if err != nil {
 		if err == sql.ErrNoRows {
-			return nil, fmt.Errorf("package %s@%s: %w", pkgPath, version, derrors.NotFound)
+			return nil, fmt.Errorf("package %s@%s: %w", pkgPath, requestedVersion, derrors.NotFound)
 		}
 		return nil, fmt.Errorf("row.Scan(): %v", err)
 	}
diff --git a/internal/postgres/path.go b/internal/postgres/path.go
index 719af787..924c6470 100644
--- a/internal/postgres/path.go
+++ b/internal/postgres/path.go
@@ -19,8 +19,8 @@ import (
 const orderByLatest = `
 			ORDER BY
 				m.incompatible,
-				CASE                          
-				    -- Order the versions by release then prerelease then pseudo.                        
+				CASE
+				    -- Order the versions by release then prerelease then pseudo.
 				    WHEN m.version_type = 'release' THEN 1
 				    WHEN m.version_type = 'prerelease' THEN 2
 				    ELSE 3
@@ -117,8 +117,8 @@ type dbPath struct {
 	redistributable bool
 }
 
-func (db *DB) getPathsInModule(ctx context.Context, modulePath, version string) (_ []*dbPath, err error) {
-	defer derrors.Wrap(&err, "DB.getPathsInModule(ctx, %q, %q)", modulePath, version)
+func (db *DB) getPathsInModule(ctx context.Context, modulePath, resolvedVersion string) (_ []*dbPath, err error) {
+	defer derrors.Wrap(&err, "DB.getPathsInModule(ctx, %q, %q)", modulePath, resolvedVersion)
 	query := `
 	SELECT
 		p.id,
@@ -150,7 +150,7 @@ func (db *DB) getPathsInModule(ctx context.Context, modulePath, version string)
 		paths = append(paths, &p)
 		return nil
 	}
-	if err := db.db.RunQuery(ctx, query, collect, modulePath, version); err != nil {
+	if err := db.db.RunQuery(ctx, query, collect, modulePath, resolvedVersion); err != nil {
 		return nil, err
 	}
 	return paths, nil
diff --git a/internal/postgres/search.go b/internal/postgres/search.go
index a9ecb6e0..dbdaf350 100644
--- a/internal/postgres/search.go
+++ b/internal/postgres/search.go
@@ -920,8 +920,8 @@ func isInternalPackage(path string) bool {
 // DeleteOlderVersionFromSearchDocuments deletes from search_documents every package with
 // the given module path whose version is older than the given version.
 // It is used when fetching a module with an alternative path. See internal/worker/fetch.go:fetchAndUpdateState.
-func (db *DB) DeleteOlderVersionFromSearchDocuments(ctx context.Context, modulePath, version string) (err error) {
-	defer derrors.Wrap(&err, "DeleteOlderVersionFromSearchDocuments(ctx, %q, %q)", modulePath, version)
+func (db *DB) DeleteOlderVersionFromSearchDocuments(ctx context.Context, modulePath, resolvedVersion string) (err error) {
+	defer derrors.Wrap(&err, "DeleteOlderVersionFromSearchDocuments(ctx, %q, %q)", modulePath, resolvedVersion)
 
 	return db.db.Transact(ctx, sql.LevelDefault, func(tx *database.DB) error {
 		// Collect all package paths in search_documents with the given module path
@@ -937,7 +937,7 @@ func (db *DB) DeleteOlderVersionFromSearchDocuments(ctx context.Context, moduleP
 			if err := rows.Scan(&ppath, &v); err != nil {
 				return err
 			}
-			if semver.Compare(v, version) < 0 {
+			if semver.Compare(v, resolvedVersion) < 0 {
 				ppaths = append(ppaths, ppath)
 			}
 			return nil
diff --git a/internal/postgres/unit.go b/internal/postgres/unit.go
index 41674f2f..2e0d2e48 100644
--- a/internal/postgres/unit.go
+++ b/internal/postgres/unit.go
@@ -74,8 +74,8 @@ func (db *DB) GetUnit(ctx context.Context, um *internal.UnitMeta, fields interna
 	return u, nil
 }
 
-func (db *DB) getPathID(ctx context.Context, fullPath, modulePath, version string) (_ int, err error) {
-	defer derrors.Wrap(&err, "getPathID(ctx, %q, %q, %q)", fullPath, modulePath, version)
+func (db *DB) getPathID(ctx context.Context, fullPath, modulePath, resolvedVersion string) (_ int, err error) {
+	defer derrors.Wrap(&err, "getPathID(ctx, %q, %q, %q)", fullPath, modulePath, resolvedVersion)
 	var pathID int
 	query := `
 		SELECT p.id
@@ -85,7 +85,7 @@ func (db *DB) getPathID(ctx context.Context, fullPath, modulePath, version strin
 		    p.path = $1
 		    AND m.module_path = $2
 		    AND m.version = $3;`
-	err = db.db.QueryRow(ctx, query, fullPath, modulePath, version).Scan(&pathID)
+	err = db.db.QueryRow(ctx, query, fullPath, modulePath, resolvedVersion).Scan(&pathID)
 	switch err {
 	case sql.ErrNoRows:
 		return 0, derrors.NotFound
@@ -129,8 +129,8 @@ func (db *DB) getDocumentation(ctx context.Context, pathID int) (_ *internal.Doc
 }
 
 // getReadme returns the README corresponding to the modulePath and version.
-func (db *DB) getReadme(ctx context.Context, modulePath, version string) (_ *internal.Readme, err error) {
-	defer derrors.Wrap(&err, "getReadme(ctx, %q, %q)", modulePath, version)
+func (db *DB) getReadme(ctx context.Context, modulePath, resolvedVersion string) (_ *internal.Readme, err error) {
+	defer derrors.Wrap(&err, "getReadme(ctx, %q, %q)", modulePath, resolvedVersion)
 	// TODO(golang/go#38513): update to query on PathID and query the readmes
 	// table directly once we start displaying READMEs for directories instead
 	// of the top-level module.
@@ -145,7 +145,7 @@ func (db *DB) getReadme(ctx context.Context, modulePath, version string) (_ *int
 		WHERE
 		    m.module_path=$1
 			AND m.version=$2
-			AND m.module_path=p.path`, modulePath, version).Scan(&readme.Filepath, &readme.Contents)
+			AND m.module_path=p.path`, modulePath, resolvedVersion).Scan(&readme.Filepath, &readme.Contents)
 	switch err {
 	case sql.ErrNoRows:
 		return nil, derrors.NotFound
diff --git a/internal/postgres/versionstate.go b/internal/postgres/versionstate.go
index 2b60f47a..adc4db31 100644
--- a/internal/postgres/versionstate.go
+++ b/internal/postgres/versionstate.go
@@ -128,8 +128,8 @@ func upsertModuleVersionState(ctx context.Context, db *database.DB, modulePath,
 
 // updateModulesStatus updates the status of the module with the given modulePath
 // and version, if it exists, in the modules table.
-func updateModulesStatus(ctx context.Context, db *database.DB, modulePath, version string, status int) (err error) {
-	defer derrors.Wrap(&err, "updateModulesStatus(%q, %q, %d)", modulePath, version, status)
+func updateModulesStatus(ctx context.Context, db *database.DB, modulePath, resolvedVersion string, status int) (err error) {
+	defer derrors.Wrap(&err, "updateModulesStatus(%q, %q, %d)", modulePath, resolvedVersion, status)
 
 	query := `UPDATE modules
 			SET
@@ -137,7 +137,7 @@ func updateModulesStatus(ctx context.Context, db *database.DB, modulePath, versi
 			WHERE
 				module_path = $2
 				AND version = $3;`
-	affected, err := db.Exec(ctx, query, status, modulePath, version)
+	affected, err := db.Exec(ctx, query, status, modulePath, resolvedVersion)
 	if err != nil {
 		return err
 	}
@@ -289,8 +289,8 @@ func (db *DB) GetRecentVersions(ctx context.Context, limit int) (_ []*internal.M
 
 // GetModuleVersionState returns the current module version state for
 // modulePath and version.
-func (db *DB) GetModuleVersionState(ctx context.Context, modulePath, version string) (_ *internal.ModuleVersionState, err error) {
-	defer derrors.Wrap(&err, "GetModuleVersionState(ctx, %q, %q)", modulePath, version)
+func (db *DB) GetModuleVersionState(ctx context.Context, modulePath, resolvedVrsion string) (_ *internal.ModuleVersionState, err error) {
+	defer derrors.Wrap(&err, "GetModuleVersionState(ctx, %q, %q)", modulePath, resolvedVrsion)
 
 	query := fmt.Sprintf(`
 		SELECT %s
@@ -300,7 +300,7 @@ func (db *DB) GetModuleVersionState(ctx context.Context, modulePath, version str
 			module_path = $1
 			AND version = $2;`, moduleVersionStateColumns)
 
-	row := db.db.QueryRow(ctx, query, modulePath, version)
+	row := db.db.QueryRow(ctx, query, modulePath, resolvedVrsion)
 	v, err := scanModuleVersionState(row.Scan)
 	switch err {
 	case nil:
@@ -314,8 +314,8 @@ func (db *DB) GetModuleVersionState(ctx context.Context, modulePath, version str
 
 // GetPackageVersionStatesForModule returns the current package version states
 // for modulePath and version.
-func (db *DB) GetPackageVersionStatesForModule(ctx context.Context, modulePath, version string) (_ []*internal.PackageVersionState, err error) {
-	defer derrors.Wrap(&err, "GetPackageVersionState(ctx, %q, %q)", modulePath, version)
+func (db *DB) GetPackageVersionStatesForModule(ctx context.Context, modulePath, resolvedVersion string) (_ []*internal.PackageVersionState, err error) {
+	defer derrors.Wrap(&err, "GetPackageVersionState(ctx, %q, %q)", modulePath, resolvedVersion)
 
 	query := `
 		SELECT
@@ -340,7 +340,7 @@ func (db *DB) GetPackageVersionStatesForModule(ctx context.Context, modulePath,
 		states = append(states, &s)
 		return nil
 	}
-	if err := db.db.RunQuery(ctx, query, collect, modulePath, version); err != nil {
+	if err := db.db.RunQuery(ctx, query, collect, modulePath, resolvedVersion); err != nil {
 		return nil, err
 	}
 	return states, nil
@@ -348,8 +348,8 @@ func (db *DB) GetPackageVersionStatesForModule(ctx context.Context, modulePath,
 
 // GetPackageVersionState returns the current package version state for
 // pkgPath, modulePath and version.
-func (db *DB) GetPackageVersionState(ctx context.Context, pkgPath, modulePath, version string) (_ *internal.PackageVersionState, err error) {
-	defer derrors.Wrap(&err, "GetPackageVersionState(ctx, %q, %q, %q)", pkgPath, modulePath, version)
+func (db *DB) GetPackageVersionState(ctx context.Context, pkgPath, modulePath, resolvedVersion string) (_ *internal.PackageVersionState, err error) {
+	defer derrors.Wrap(&err, "GetPackageVersionState(ctx, %q, %q, %q)", pkgPath, modulePath, resolvedVersion)
 
 	query := `
 		SELECT
@@ -366,7 +366,7 @@ func (db *DB) GetPackageVersionState(ctx context.Context, pkgPath, modulePath, v
 			AND version = $3;`
 
 	var pvs internal.PackageVersionState
-	err = db.db.QueryRow(ctx, query, pkgPath, modulePath, version).Scan(
+	err = db.db.QueryRow(ctx, query, pkgPath, modulePath, resolvedVersion).Scan(
 		&pvs.PackagePath, &pvs.ModulePath, &pvs.Version,
 		&pvs.Status, &pvs.Error)
 	switch err {