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>
diff --git a/internal/postgres/details.go b/internal/postgres/details.go
index 23a898c..7078fd8 100644
--- a/internal/postgres/details.go
+++ b/internal/postgres/details.go
@@ -64,7 +64,7 @@
// 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 @@
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 @@
//
// 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 @@
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 @@
// 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 @@
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 @@
// 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 @@
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 @@
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 4b7529c..e7ed5b1 100644
--- a/internal/postgres/insert_module.go
+++ b/internal/postgres/insert_module.go
@@ -561,7 +561,7 @@
}
// 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 @@
}
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 @@
}
// 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 019d8ae..ef02a45 100644
--- a/internal/postgres/legacy_directory.go
+++ b/internal/postgres/legacy_directory.go
@@ -53,10 +53,10 @@
//
// 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 @@
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 @@
// 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 @@
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 b95970d..6ca9d14 100644
--- a/internal/postgres/licenses.go
+++ b/internal/postgres/licenses.go
@@ -93,10 +93,10 @@
// 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 @@
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 @@
// 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 @@
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 65c0757..dd808c8 100644
--- a/internal/postgres/package.go
+++ b/internal/postgres/package.go
@@ -41,9 +41,9 @@
// 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 @@
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 @@
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 @@
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 @@
&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 719af78..924c647 100644
--- a/internal/postgres/path.go
+++ b/internal/postgres/path.go
@@ -19,8 +19,8 @@
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 @@
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 @@
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 a9ecb6e..dbdaf35 100644
--- a/internal/postgres/search.go
+++ b/internal/postgres/search.go
@@ -920,8 +920,8 @@
// 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 @@
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 41674f2..2e0d2e4 100644
--- a/internal/postgres/unit.go
+++ b/internal/postgres/unit.go
@@ -74,8 +74,8 @@
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 @@
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 @@
}
// 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 @@
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 2b60f47..adc4db3 100644
--- a/internal/postgres/versionstate.go
+++ b/internal/postgres/versionstate.go
@@ -128,8 +128,8 @@
// 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 @@
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 @@
// 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 @@
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 @@
// 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 @@
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 @@
// 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 @@
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 {
