database: use constants to store queries

database/pgsql/complex_test.go

@@ -128,7 +128,7 @@ func TestRaceAffects(t *testing.T) {
 		featureVersionVersion, _ := strconv.Atoi(featureVersion.Version.String())
 
 		// Get actual affects.
-		rows, err := datastore.Query(getQuery("s_complextest_featureversion_affects"),
+		rows, err := datastore.Query(searchComplexTestFeatureVersionAffects,
 			featureVersion.ID)
 		assert.Nil(t, err)
 		defer rows.Close()

database/pgsql/feature.go

@@ -49,9 +49,9 @@ func (pgSQL *pgSQL) insertFeature(feature database.Feature) (int, error) {
 
 	// Find or create Feature.
 	var id int
-	err = pgSQL.QueryRow(getQuery("soi_feature"), feature.Name, namespaceID).Scan(&id)
+	err = pgSQL.QueryRow(soiFeature, feature.Name, namespaceID).Scan(&id)
 	if err != nil {
-		return 0, handleError("soi_feature", err)
+		return 0, handleError("soiFeature", err)
 	}
 
 	if pgSQL.cache != nil {
@@ -103,25 +103,25 @@ func (pgSQL *pgSQL) insertFeatureVersion(featureVersion database.FeatureVersion)
 	promConcurrentLockVAFV.Inc()
 	defer promConcurrentLockVAFV.Dec()
 	t = time.Now()
-	_, err = tx.Exec(getQuery("l_vulnerability_affects_featureversion"))
+	_, err = tx.Exec(lockVulnerabilityAffects)
 	observeQueryTime("insertFeatureVersion", "lock", t)
 
 	if err != nil {
 		tx.Rollback()
-		return 0, handleError("insertFeatureVersion.l_vulnerability_affects_featureversion", err)
+		return 0, handleError("insertFeatureVersion.lockVulnerabilityAffects", err)
 	}
 
 	// Find or create FeatureVersion.
 	var newOrExisting string
 
 	t = time.Now()
-	err = tx.QueryRow(getQuery("soi_featureversion"), featureID, &featureVersion.Version).
+	err = tx.QueryRow(soiFeatureVersion, featureID, &featureVersion.Version).
 		Scan(&newOrExisting, &featureVersion.ID)
-	observeQueryTime("insertFeatureVersion", "soi_featureversion", t)
+	observeQueryTime("insertFeatureVersion", "soiFeatureVersion", t)
 
 	if err != nil {
 		tx.Rollback()
-		return 0, handleError("soi_featureversion", err)
+		return 0, handleError("soiFeatureVersion", err)
 	}
 
 	if newOrExisting == "exi" {
@@ -183,9 +183,9 @@ type vulnerabilityAffectsFeatureVersion struct {
 func linkFeatureVersionToVulnerabilities(tx *sql.Tx, featureVersion database.FeatureVersion) error {
 	// Select every vulnerability and the fixed version that affect this Feature.
 	// TODO(Quentin-M): LIMIT
-	rows, err := tx.Query(getQuery("s_vulnerability_fixedin_feature"), featureVersion.Feature.ID)
+	rows, err := tx.Query(searchVulnerabilityFixedInFeature, featureVersion.Feature.ID)
 	if err != nil {
-		return handleError("s_vulnerability_fixedin_feature", err)
+		return handleError("searchVulnerabilityFixedInFeature", err)
 	}
 	defer rows.Close()
 
@@ -195,7 +195,7 @@ func linkFeatureVersionToVulnerabilities(tx *sql.Tx, featureVersion database.Fea
 
 		err := rows.Scan(&affect.fixedInID, &affect.vulnerabilityID, &affect.fixedInVersion)
 		if err != nil {
-			return handleError("s_vulnerability_fixedin_feature.Scan()", err)
+			return handleError("searchVulnerabilityFixedInFeature.Scan()", err)
 		}
 
 		if featureVersion.Version.Compare(affect.fixedInVersion) < 0 {
@@ -205,17 +205,17 @@ func linkFeatureVersionToVulnerabilities(tx *sql.Tx, featureVersion database.Fea
 		}
 	}
 	if err = rows.Err(); err != nil {
-		return handleError("s_vulnerability_fixedin_feature.Rows()", err)
+		return handleError("searchVulnerabilityFixedInFeature.Rows()", err)
 	}
 	rows.Close()
 
 	// Insert into Vulnerability_Affects_FeatureVersion.
 	for _, affect := range affects {
 		// TODO(Quentin-M): Batch me.
-		_, err := tx.Exec(getQuery("i_vulnerability_affects_featureversion"), affect.vulnerabilityID,
+		_, err := tx.Exec(insertVulnerabilityAffectsFeatureVersion, affect.vulnerabilityID,
 			featureVersion.ID, affect.fixedInID)
 		if err != nil {
-			return handleError("i_vulnerability_affects_featureversion", err)
+			return handleError("insertVulnerabilityAffectsFeatureVersion", err)
 		}
 	}
 

database/pgsql/keyvalue.go

@@ -41,9 +41,9 @@ func (pgSQL *pgSQL) InsertKeyValue(key, value string) (err error) {
 
 	for {
 		// First, try to update.
-		r, err := pgSQL.Exec(getQuery("u_keyvalue"), value, key)
+		r, err := pgSQL.Exec(updateKeyValue, value, key)
 		if err != nil {
-			return handleError("u_keyvalue", err)
+			return handleError("updateKeyValue", err)
 		}
 		if n, _ := r.RowsAffected(); n > 0 {
 			// Updated successfully.
@@ -52,13 +52,13 @@ func (pgSQL *pgSQL) InsertKeyValue(key, value string) (err error) {
 
 		// Try to insert the key.
 		// If someone else inserts the same key concurrently, we could get a unique-key violation error.
-		_, err = pgSQL.Exec(getQuery("i_keyvalue"), key, value)
+		_, err = pgSQL.Exec(insertKeyValue, key, value)
 		if err != nil {
 			if isErrUniqueViolation(err) {
 				// Got unique constraint violation, retry.
 				continue
 			}
-			return handleError("i_keyvalue", err)
+			return handleError("insertKeyValue", err)
 		}
 
 		return nil
@@ -70,13 +70,13 @@ func (pgSQL *pgSQL) GetKeyValue(key string) (string, error) {
 	defer observeQueryTime("GetKeyValue", "all", time.Now())
 
 	var value string
-	err := pgSQL.QueryRow(getQuery("s_keyvalue"), key).Scan(&value)
+	err := pgSQL.QueryRow(searchKeyValue, key).Scan(&value)
 
 	if err == sql.ErrNoRows {
 		return "", nil
 	}
 	if err != nil {
-		return "", handleError("s_keyvalue", err)
+		return "", handleError("searchKeyValue", err)
 	}
 
 	return value, nil

database/pgsql/layer.go

@@ -41,13 +41,13 @@ func (pgSQL *pgSQL) FindLayer(name string, withFeatures, withVulnerabilities boo
 	var namespaceName sql.NullString
 
 	t := time.Now()
-	err := pgSQL.QueryRow(getQuery("s_layer"), name).
+	err := pgSQL.QueryRow(searchLayer, name).
 		Scan(&layer.ID, &layer.Name, &layer.EngineVersion, &parentID, &parentName, &namespaceID,
 		&namespaceName)
-	observeQueryTime("FindLayer", "s_layer", t)
+	observeQueryTime("FindLayer", "searchLayer", t)
 
 	if err != nil {
-		return layer, handleError("s_layer", err)
+		return layer, handleError("searchLayer", err)
 	}
 
 	if !parentID.IsZero() {
@@ -78,11 +78,11 @@ func (pgSQL *pgSQL) FindLayer(name string, withFeatures, withVulnerabilities boo
 		}
 		defer tx.Commit()
 
-		_, err = tx.Exec(getQuery("disable_hashjoin"))
+		_, err = tx.Exec(disableHashJoin)
 		if err != nil {
 			log.Warningf("FindLayer: could not disable hash join: %s", err)
 		}
-		_, err = tx.Exec(getQuery("disable_mergejoin"))
+		_, err = tx.Exec(disableMergeJoin)
 		if err != nil {
 			log.Warningf("FindLayer: could not disable merge join: %s", err)
 		}
@@ -117,9 +117,9 @@ func getLayerFeatureVersions(tx *sql.Tx, layerID int) ([]database.FeatureVersion
 	var featureVersions []database.FeatureVersion
 
 	// Query.
-	rows, err := tx.Query(getQuery("s_layer_featureversion"), layerID)
+	rows, err := tx.Query(searchLayerFeatureVersion, layerID)
 	if err != nil {
-		return featureVersions, handleError("s_layer_featureversion", err)
+		return featureVersions, handleError("searchLayerFeatureVersion", err)
 	}
 	defer rows.Close()
 
@@ -134,7 +134,7 @@ func getLayerFeatureVersions(tx *sql.Tx, layerID int) ([]database.FeatureVersion
 			&featureVersion.Feature.Name, &featureVersion.ID, &featureVersion.Version,
 			&featureVersion.AddedBy.ID, &featureVersion.AddedBy.Name)
 		if err != nil {
-			return featureVersions, handleError("s_layer_featureversion.Scan()", err)
+			return featureVersions, handleError("searchLayerFeatureVersion.Scan()", err)
 		}
 
 		// Do transitive closure.
@@ -149,7 +149,7 @@ func getLayerFeatureVersions(tx *sql.Tx, layerID int) ([]database.FeatureVersion
 		}
 	}
 	if err = rows.Err(); err != nil {
-		return featureVersions, handleError("s_layer_featureversion.Rows()", err)
+		return featureVersions, handleError("searchLayerFeatureVersion.Rows()", err)
 	}
 
 	// Build result by converting our map to a slice.
@@ -173,10 +173,10 @@ func loadAffectedBy(tx *sql.Tx, featureVersions []database.FeatureVersion) error
 		featureVersionIDs = append(featureVersionIDs, featureVersions[i].ID)
 	}
 
-	rows, err := tx.Query(getQuery("s_featureversions_vulnerabilities"),
+	rows, err := tx.Query(searchFeatureVersionVulnerability,
 		buildInputArray(featureVersionIDs))
 	if err != nil && err != sql.ErrNoRows {
-		return handleError("s_featureversions_vulnerabilities", err)
+		return handleError("searchFeatureVersionVulnerability", err)
 	}
 	defer rows.Close()
 
@@ -188,12 +188,12 @@ func loadAffectedBy(tx *sql.Tx, featureVersions []database.FeatureVersion) error
 			&vulnerability.Description, &vulnerability.Link, &vulnerability.Severity,
 			&vulnerability.Metadata, &vulnerability.Namespace.Name, &vulnerability.FixedBy)
 		if err != nil {
-			return handleError("s_featureversions_vulnerabilities.Scan()", err)
+			return handleError("searchFeatureVersionVulnerability.Scan()", err)
 		}
 		vulnerabilities[featureversionID] = append(vulnerabilities[featureversionID], vulnerability)
 	}
 	if err = rows.Err(); err != nil {
-		return handleError("s_featureversions_vulnerabilities.Rows()", err)
+		return handleError("searchFeatureVersionVulnerability.Rows()", err)
 	}
 
 	// Assign vulnerabilities to every FeatureVersions
@@ -271,7 +271,7 @@ func (pgSQL *pgSQL) InsertLayer(layer database.Layer) error {
 
 	if layer.ID == 0 {
 		// Insert a new layer.
-		err = tx.QueryRow(getQuery("i_layer"), layer.Name, layer.EngineVersion, parentID, namespaceID).
+		err = tx.QueryRow(insertLayer, layer.Name, layer.EngineVersion, parentID, namespaceID).
 			Scan(&layer.ID)
 		if err != nil {
 			tx.Rollback()
@@ -280,21 +280,21 @@ func (pgSQL *pgSQL) InsertLayer(layer database.Layer) error {
 				// Ignore this error, another process collided.
 				return nil
 			}
-			return handleError("i_layer", err)
+			return handleError("insertLayer", err)
 		}
 	} else {
 		// Update an existing layer.
-		_, err = tx.Exec(getQuery("u_layer"), layer.ID, layer.EngineVersion, namespaceID)
+		_, err = tx.Exec(updateLayer, layer.ID, layer.EngineVersion, namespaceID)
 		if err != nil {
 			tx.Rollback()
-			return handleError("u_layer", err)
+			return handleError("updateLayer", err)
 		}
 
 		// Remove all existing Layer_diff_FeatureVersion.
-		_, err = tx.Exec(getQuery("r_layer_diff_featureversion"), layer.ID)
+		_, err = tx.Exec(removeLayerDiffFeatureVersion, layer.ID)
 		if err != nil {
 			tx.Rollback()
-			return handleError("r_layer_diff_featureversion", err)
+			return handleError("removeLayerDiffFeatureVersion", err)
 		}
 	}
 
@@ -355,15 +355,15 @@ func (pgSQL *pgSQL) updateDiffFeatureVersions(tx *sql.Tx, layer, existingLayer *
 
 	// Insert diff in the database.
 	if len(addIDs) > 0 {
-		_, err = tx.Exec(getQuery("i_layer_diff_featureversion"), layer.ID, "add", buildInputArray(addIDs))
+		_, err = tx.Exec(insertLayerDiffFeatureVersion, layer.ID, "add", buildInputArray(addIDs))
 		if err != nil {
-			return handleError("i_layer_diff_featureversion.Add", err)
+			return handleError("insertLayerDiffFeatureVersion.Add", err)
 		}
 	}
 	if len(delIDs) > 0 {
-		_, err = tx.Exec(getQuery("i_layer_diff_featureversion"), layer.ID, "del", buildInputArray(delIDs))
+		_, err = tx.Exec(insertLayerDiffFeatureVersion, layer.ID, "del", buildInputArray(delIDs))
 		if err != nil {
-			return handleError("i_layer_diff_featureversion.Del", err)
+			return handleError("insertLayerDiffFeatureVersion.Del", err)
 		}
 	}
 
@@ -387,14 +387,14 @@ func createNV(features []database.FeatureVersion) (map[string]*database.FeatureV
 func (pgSQL *pgSQL) DeleteLayer(name string) error {
 	defer observeQueryTime("DeleteLayer", "all", time.Now())
 
-	result, err := pgSQL.Exec(getQuery("r_layer"), name)
+	result, err := pgSQL.Exec(removeLayer, name)
 	if err != nil {
-		return handleError("r_layer", err)
+		return handleError("removeLayer", err)
 	}
 
 	affected, err := result.RowsAffected()
 	if err != nil {
-		return handleError("r_layer.RowsAffected()", err)
+		return handleError("removeLayer.RowsAffected()", err)
 	}
 
 	if affected <= 0 {

database/pgsql/lock.go

@@ -37,9 +37,9 @@ func (pgSQL *pgSQL) Lock(name string, owner string, duration time.Duration, rene
 
 	if renew {
 		// Renew lock.
-		r, err := pgSQL.Exec(getQuery("u_lock"), name, owner, until)
+		r, err := pgSQL.Exec(updateLock, name, owner, until)
 		if err != nil {
-			handleError("u_lock", err)
+			handleError("updateLock", err)
 			return false, until
 		}
 		if n, _ := r.RowsAffected(); n > 0 {
@@ -52,10 +52,10 @@ func (pgSQL *pgSQL) Lock(name string, owner string, duration time.Duration, rene
 	}
 
 	// Lock.
-	_, err := pgSQL.Exec(getQuery("i_lock"), name, owner, until)
+	_, err := pgSQL.Exec(insertLock, name, owner, until)
 	if err != nil {
 		if !isErrUniqueViolation(err) {
-			handleError("i_lock", err)
+			handleError("insertLock", err)
 		}
 		return false, until
 	}
@@ -72,7 +72,7 @@ func (pgSQL *pgSQL) Unlock(name, owner string) {
 
 	defer observeQueryTime("Unlock", "all", time.Now())
 
-	pgSQL.Exec(getQuery("r_lock"), name, owner)
+	pgSQL.Exec(removeLock, name, owner)
 }
 
 // FindLock returns the owner of a lock specified by its name and its
@@ -87,9 +87,9 @@ func (pgSQL *pgSQL) FindLock(name string) (string, time.Time, error) {
 
 	var owner string
 	var until time.Time
-	err := pgSQL.QueryRow(getQuery("f_lock"), name).Scan(&owner, &until)
+	err := pgSQL.QueryRow(searchLock, name).Scan(&owner, &until)
 	if err != nil {
-		return owner, until, handleError("f_lock", err)
+		return owner, until, handleError("searchLock", err)
 	}
 
 	return owner, until, nil
@@ -99,7 +99,7 @@ func (pgSQL *pgSQL) FindLock(name string) (string, time.Time, error) {
 func (pgSQL *pgSQL) pruneLocks() {
 	defer observeQueryTime("pruneLocks", "all", time.Now())
 
-	if _, err := pgSQL.Exec(getQuery("r_lock_expired")); err != nil {
-		handleError("r_lock_expired", err)
+	if _, err := pgSQL.Exec(removeLockExpired); err != nil {
+		handleError("removeLockExpired", err)
 	}
 }

database/pgsql/namespace.go

@@ -38,9 +38,9 @@ func (pgSQL *pgSQL) insertNamespace(namespace database.Namespace) (int, error) {
 	defer observeQueryTime("insertNamespace", "all", time.Now())
 
 	var id int
-	err := pgSQL.QueryRow(getQuery("soi_namespace"), namespace.Name).Scan(&id)
+	err := pgSQL.QueryRow(soiNamespace, namespace.Name).Scan(&id)
 	if err != nil {
-		return 0, handleError("soi_namespace", err)
+		return 0, handleError("soiNamespace", err)
 	}
 
 	if pgSQL.cache != nil {
@@ -51,9 +51,9 @@ func (pgSQL *pgSQL) insertNamespace(namespace database.Namespace) (int, error) {
 }
 
 func (pgSQL *pgSQL) ListNamespaces() (namespaces []database.Namespace, err error) {
-	rows, err := pgSQL.Query(getQuery("l_namespace"))
+	rows, err := pgSQL.Query(listNamespace)
 	if err != nil {
-		return namespaces, handleError("l_namespace", err)
+		return namespaces, handleError("listNamespace", err)
 	}
 	defer rows.Close()
 
@@ -62,13 +62,13 @@ func (pgSQL *pgSQL) ListNamespaces() (namespaces []database.Namespace, err error
 
 		err = rows.Scan(&namespace.ID, &namespace.Name)
 		if err != nil {
-			return namespaces, handleError("l_namespace.Scan()", err)
+			return namespaces, handleError("listNamespace.Scan()", err)
 		}
 
 		namespaces = append(namespaces, namespace)
 	}
 	if err = rows.Err(); err != nil {
-		return namespaces, handleError("l_namespace.Rows()", err)
+		return namespaces, handleError("listNamespace.Rows()", err)
 	}
 
 	return namespaces, err