Declare only the tables and columns pixa writes and reads (closes #310)

Removes output_content and request_cache, which nothing writes, and every
column that was written but never read: the host, path, query, content_type
and fetched_at of source_content, the content_type and created_at of
variant_content, and the status_code, error_message and fetched_at of
negative_cache.

StoreSource no longer takes the fetch result and LookupSource returns only
the source key. StoreVariant no longer takes a content type and
StoreNegative no longer takes a status code or message, so
extractStatusCode and the status constants, which only fed status_code,
are gone. Reconciliation adopts a variant file without opening it, as its
row no longer records a content type. Tests that set or checked a removed
column follow.

Model: opus-5-5

internal/imgcache/cache.go

@@ -12,7 +12,6 @@ import (
 	"sync/atomic"
 	"time"
 
-	"sneak.berlin/go/pixa/internal/httpfetcher"
 	"sneak.berlin/go/pixa/internal/imagerequest"
 )
 
@@ -212,7 +211,6 @@ func (c *Cache) StoreSource(
 	ctx context.Context,
 	req *imagerequest.Request,
 	content io.Reader,
-	result *httpfetcher.FetchResult,
 ) (imagerequest.SourceKey, error) {
 	if c.disabled {
 		return "", nil
@@ -231,17 +229,12 @@ func (c *Cache) StoreSource(
 	}
 
 	_, err = c.db.ExecContext(ctx, `
-		INSERT INTO source_content
-			(source_key, source_host, source_path, source_query,
-			 content_type, size_bytes)
-		VALUES (?, ?, ?, ?, ?, ?)
+		INSERT INTO source_content (source_key, size_bytes)
+		VALUES (?, ?)
 		ON CONFLICT(source_key) DO UPDATE SET
-			content_type = excluded.content_type,
 			size_bytes = excluded.size_bytes,
-			fetched_at = CURRENT_TIMESTAMP,
 			last_accessed_at = CURRENT_TIMESTAMP
-	`, string(key), req.Source.Host, req.Source.Path, req.Source.Query,
-		result.ContentType, size)
+	`, string(key), size)
 	if err != nil {
 		deleteErr := c.srcContent.Delete(key)
 		if deleteErr != nil {
@@ -262,8 +255,7 @@ func (c *Cache) StoreSource(
 // accounting insert is best-effort (the startup reconciliation pass
 // adopts any variant file that misses its accounting row).
 func (c *Cache) StoreVariant(
-	ctx context.Context, cacheKey imagerequest.VariantKey,
-	content io.Reader, contentType string,
+	ctx context.Context, cacheKey imagerequest.VariantKey, content io.Reader,
 ) error {
 	if c.disabled {
 		return nil
@@ -275,13 +267,12 @@ func (c *Cache) StoreVariant(
 	}
 
 	_, err = c.db.ExecContext(ctx, `
-		INSERT INTO variant_content (cache_key, size_bytes, content_type)
-		VALUES (?, ?, ?)
+		INSERT INTO variant_content (cache_key, size_bytes)
+		VALUES (?, ?)
 		ON CONFLICT(cache_key) DO UPDATE SET
 			size_bytes = excluded.size_bytes,
-			content_type = excluded.content_type,
 			last_accessed_at = CURRENT_TIMESTAMP
-	`, string(cacheKey), size, contentType)
+	`, string(cacheKey), size)
 	if err != nil {
 		c.log.Warn("failed to record variant in size accounting",
 			"cache_key", cacheKey, "error", err)
@@ -293,60 +284,54 @@ func (c *Cache) StoreVariant(
 }
 
 // LookupSource checks if we have cached source content for a request.
-// Returns the source key and content type if found, or empty values
-// if not; a row whose file is missing is not found. A source found has
-// its access time handed to the background writer without waiting (see
+// Returns the source key if found, or an empty key if not; a row whose
+// file is missing is not found. A source found has its access time
+// handed to the background writer without waiting (see
 // touchSourceContent); a disabled cache always reports no cached source.
 func (c *Cache) LookupSource(
 	ctx context.Context, req *imagerequest.Request,
-) (imagerequest.SourceKey, string, error) {
+) (imagerequest.SourceKey, error) {
 	if c.disabled {
-		return "", "", nil
+		return "", nil
 	}
 
 	key := req.Source.Key()
 
-	var contentType string
+	var foundKey string
 
 	err := c.db.QueryRowContext(ctx, `
-		SELECT content_type FROM source_content WHERE source_key = ?
-	`, string(key)).Scan(&contentType)
+		SELECT source_key FROM source_content WHERE source_key = ?
+	`, string(key)).Scan(&foundKey)
 
 	if errors.Is(err, sql.ErrNoRows) {
-		return "", "", nil
+		return "", nil
 	}
 
 	if err != nil {
-		return "", "", fmt.Errorf("failed to lookup source: %w", err)
+		return "", fmt.Errorf("failed to lookup source: %w", err)
 	}
 
 	// Verify the content file exists
 	if !c.srcContent.Exists(key) {
-		return "", "", nil
+		return "", nil
 	}
 
 	c.touchSourceContent(key)
 
-	return key, contentType, nil
+	return key, nil
 }
 
 // StoreNegative stores a negative cache entry for a failed fetch.
-func (c *Cache) StoreNegative(
-	ctx context.Context, req *imagerequest.Request, statusCode int, errMsg string,
-) error {
+func (c *Cache) StoreNegative(ctx context.Context, req *imagerequest.Request) error {
 	expiresAt := time.Now().UTC().Add(c.config.NegativeTTL)
 
 	_, err := c.db.ExecContext(ctx, `
 		INSERT INTO negative_cache
-			(source_host, source_path, source_query, status_code,
-			 error_message, expires_at)
-		VALUES (?, ?, ?, ?, ?, ?)
+			(source_host, source_path, source_query, expires_at)
+		VALUES (?, ?, ?, ?)
 		ON CONFLICT(source_host, source_path, source_query) DO UPDATE SET
-			status_code = excluded.status_code,
-			error_message = excluded.error_message,
-			fetched_at = CURRENT_TIMESTAMP,
 			expires_at = excluded.expires_at
-	`, req.Source.Host, req.Source.Path, req.Source.Query, statusCode, errMsg, expiresAt)
+	`, req.Source.Host, req.Source.Path, req.Source.Query, expiresAt)
 	if err != nil {
 		return fmt.Errorf("failed to insert negative cache: %w", err)
 	}