package postgres import ( "context" "encoding/json" "errors" "strings" "testing" "time" "github.com/jackc/pgx/v5" "github.com/jackc/pgx/v5/pgconn" "knowledge-governance/internal/governance" ) func TestLoadPublicationForUploadMapsVerifiedCandidate(t *testing.T) { db := &recordingDB{row: publicationUploadRow{}} candidate, err := NewStore(db).LoadPublicationForUpload(context.Background(), "publication-1") if err != nil { t.Fatalf("LoadPublicationForUpload() error = %v", err) } if candidate.ID != "publication-1" || candidate.SourceItemVersionID != "version-1" || candidate.ContentObjectID != "content-1" { t.Fatalf("candidate identities = %#v", candidate) } if candidate.TestKBID != "kb-1" || candidate.IngestState != governance.IngestPending || candidate.ProcessingState != governance.ProcessingPending { t.Fatalf("candidate states = %#v", candidate) } if candidate.TargetScope != "internal" { t.Fatalf("candidate target scope = %q", candidate.TargetScope) } if candidate.SHA256 != "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" || candidate.SizeBytes != 24 || candidate.ValidatedFormat != "md" || candidate.LocalSpoolRef != "objects/artifact.md" { t.Fatalf("candidate content = %#v", candidate) } if db.queryRowSQL != loadPublicationForUploadSQL || len(db.queryRowArgs) != 1 || db.queryRowArgs[0] != "publication-1" { t.Fatalf("query = %q %#v", db.queryRowSQL, db.queryRowArgs) } } func TestMarkUploadingRejectsStalePublicationState(t *testing.T) { db := &recordingDB{commandTag: pgconn.NewCommandTag("UPDATE 0")} err := NewStore(db).MarkUploading(context.Background(), "publication-1", time.Date(2026, time.September, 4, 2, 0, 0, 0, time.UTC)) if !errors.Is(err, ErrPublicationStateConflict) { t.Fatalf("MarkUploading() error = %v, want ErrPublicationStateConflict", err) } if db.execSQL != markUploadingSQL { t.Fatalf("MarkUploading() SQL = %q", db.execSQL) } } func TestRecordUploadAndSchedulePollIsAtomicAndIdempotent(t *testing.T) { db := &recordingDB{row: sequenceRow{sequence: 1}} now := time.Date(2026, time.September, 4, 2, 5, 0, 0, time.UTC) nextAt := now.Add(10 * time.Second) sequence, err := NewStore(db).RecordUploadAndSchedulePoll(context.Background(), "publication-1", "knowledge-1", now, nextAt) if err != nil { t.Fatalf("RecordUploadAndSchedulePoll() error = %v", err) } if sequence != 1 { t.Fatalf("sequence = %d, want 1", sequence) } updateAt := strings.Index(recordUploadAndSchedulePollSQL, "UPDATE test_publications") insertAt := strings.Index(recordUploadAndSchedulePollSQL, "INSERT INTO jobs") if updateAt < 0 || insertAt < 0 || updateAt >= insertAt { t.Fatalf("atomic SQL missing ordered update/insert: %q", recordUploadAndSchedulePollSQL) } if db.queryRowSQL != recordUploadAndSchedulePollSQL || len(db.queryRowArgs) != 7 { t.Fatalf("query = %q %#v", db.queryRowSQL, db.queryRowArgs) } if !strings.Contains(recordUploadAndSchedulePollSQL, "'test-poll:' || $1 || ':' || updated.retry_count || ':1'") { t.Fatalf("poll schedule key must carry the retry round: %q", recordUploadAndSchedulePollSQL) } var payload map[string]any if err := json.Unmarshal(db.queryRowArgs[3].([]byte), &payload); err != nil { t.Fatal(err) } if len(payload) != 2 || payload["publication_id"] != "publication-1" || payload["sequence"] != float64(1) { t.Fatalf("payload = %#v", payload) } } func TestRecordRemoteStatusSchedulesNextSequenceAtomically(t *testing.T) { db := &recordingDB{row: sequenceRow{sequence: 2}} observedAt := time.Date(2026, time.September, 4, 2, 6, 0, 0, time.UTC) remoteUpdatedAt := observedAt.Add(-time.Second) nextAt := observedAt.Add(30 * time.Second) sequence, err := NewStore(db).RecordRemoteStatusAndScheduleNextPoll( context.Background(), "publication-1", 1, governance.ProcessingProcessing, &remoteUpdatedAt, observedAt, nextAt, ) if err != nil { t.Fatalf("RecordRemoteStatusAndScheduleNextPoll() error = %v", err) } if sequence != 2 { t.Fatalf("sequence = %d, want 2", sequence) } if !strings.Contains(recordRemoteStatusAndScheduleNextPollSQL, "poll_sequence = $2") || !strings.Contains(recordRemoteStatusAndScheduleNextPollSQL, "INSERT INTO jobs") { t.Fatalf("SQL lacks sequence guard or atomic enqueue: %q", recordRemoteStatusAndScheduleNextPollSQL) } if db.queryRowSQL != recordRemoteStatusAndScheduleNextPollSQL || len(db.queryRowArgs) != 9 { t.Fatalf("query = %q %#v", db.queryRowSQL, db.queryRowArgs) } if !strings.Contains(recordRemoteStatusAndScheduleNextPollSQL, "'test-poll:' || $1 || ':' || updated.retry_count || ':' || updated.poll_sequence") { t.Fatalf("next-poll schedule key must carry the retry round: %q", recordRemoteStatusAndScheduleNextPollSQL) } } func TestRecordCompletedSchedulesValidationAtomically(t *testing.T) { db := &recordingDB{row: sequenceRow{sequence: 3}} observedAt := time.Date(2026, time.September, 4, 2, 7, 0, 0, time.UTC) remoteUpdatedAt := observedAt.Add(-time.Second) err := NewStore(db).RecordCompletedAndScheduleValidation( context.Background(), "publication-1", 3, &remoteUpdatedAt, observedAt, ) if err != nil { t.Fatalf("RecordCompletedAndScheduleValidation() error = %v", err) } if !strings.Contains(recordCompletedAndScheduleValidationSQL, "processing_state = 'completed'") || !strings.Contains(recordCompletedAndScheduleValidationSQL, "'test.validate'") { t.Fatalf("SQL lacks completed update or validation enqueue: %q", recordCompletedAndScheduleValidationSQL) } if !strings.Contains(recordCompletedAndScheduleValidationSQL, "parser_generation = $7") || !strings.Contains(recordCompletedAndScheduleValidationSQL, "index_generation = $8") { t.Fatalf("SQL lacks release generation stamping: %q", recordCompletedAndScheduleValidationSQL) } if db.queryRowSQL != recordCompletedAndScheduleValidationSQL || len(db.queryRowArgs) != 10 { t.Fatalf("query = %q %#v", db.queryRowSQL, db.queryRowArgs) } if db.queryRowArgs[6] != "weknora-v0.7.1-m74@2026-09-04T02:06:59Z" || db.queryRowArgs[7] != "weknora-v0.7.1-m74@2026-09-04T02:06:59Z" { t.Fatalf("generation args = %#v", db.queryRowArgs[6:]) } if !strings.Contains(recordCompletedAndScheduleValidationSQL, "'test-validate:' || $1 || ':' || updated.retry_count || ':' || updated.poll_sequence") { t.Fatalf("validate schedule key must carry the retry round: %q", recordCompletedAndScheduleValidationSQL) } } func TestLoadPublicationForPollMapsOnlyProcessingProjection(t *testing.T) { now := time.Date(2026, time.September, 4, 2, 8, 0, 0, time.UTC) db := &recordingDB{row: publicationPollRow{now: now}} publication, err := NewStore(db).LoadPublicationForPoll(context.Background(), "publication-1") if err != nil { t.Fatalf("LoadPublicationForPoll() error = %v", err) } if publication.ID != "publication-1" || publication.TestKBID != "kb-1" || publication.KnowledgeID != "knowledge-1" { t.Fatalf("publication identities = %#v", publication) } if publication.ProcessingState != governance.ProcessingProcessing || publication.PollSequence != 2 || publication.LastRemoteStatus != "processing" { t.Fatalf("publication state = %#v", publication) } if publication.LastProgressAt == nil || !publication.LastProgressAt.Equal(now) { t.Fatalf("last progress = %#v", publication.LastProgressAt) } if db.queryRowSQL != loadPublicationForPollSQL { t.Fatalf("query = %q", db.queryRowSQL) } } func TestRecordProcessingFailureStoresOnlyFixedErrorCode(t *testing.T) { now := time.Date(2026, time.September, 4, 2, 9, 0, 0, time.UTC) for _, code := range []string{"remote detail", "https://example.com", strings.Repeat("x", 65)} { db := &recordingDB{commandTag: pgconn.NewCommandTag("UPDATE 1")} if err := NewStore(db).RecordProcessingFailure(context.Background(), "publication-1", 2, code, now); !errors.Is(err, ErrInvalidErrorCode) { t.Fatalf("RecordProcessingFailure(%q) error = %v", code, err) } if db.execSQL != "" { t.Fatalf("invalid code %q reached database", code) } } db := &recordingDB{commandTag: pgconn.NewCommandTag("UPDATE 1")} if err := NewStore(db).RecordProcessingFailure(context.Background(), "publication-1", 2, "remote_parse_failed", now); err != nil { t.Fatalf("RecordProcessingFailure() error = %v", err) } if db.execSQL != recordProcessingFailureSQL || db.execArgs[2] != "remote_parse_failed" { t.Fatalf("failure update = %q %#v", db.execSQL, db.execArgs) } } func TestRecordUploadFailureStoresOnlyFixedErrorCode(t *testing.T) { now := time.Date(2026, time.September, 4, 2, 9, 30, 0, time.UTC) db := &recordingDB{commandTag: pgconn.NewCommandTag("UPDATE 1")} if err := NewStore(db).RecordUploadFailure(context.Background(), "publication-1", "upload_identity_ambiguous", now); err != nil { t.Fatalf("RecordUploadFailure() error = %v", err) } if db.execSQL != recordUploadFailureSQL || db.execArgs[1] != "upload_identity_ambiguous" { t.Fatalf("recorded upload failure args = %#v", db.execArgs) } if !strings.Contains(recordUploadFailureSQL, "processing_state = 'failed'") { t.Fatal("upload terminal failure must enter retryable processing_state=failed") } invalidDB := &recordingDB{commandTag: pgconn.NewCommandTag("UPDATE 1")} if err := NewStore(invalidDB).RecordUploadFailure(context.Background(), "publication-1", "remote body: token=secret", now); !errors.Is(err, ErrInvalidErrorCode) { t.Fatalf("invalid error code result = %v", err) } if invalidDB.execSQL != "" { t.Fatal("invalid error code reached database") } } func TestLoadPublicationForValidationMapsCompletedContext(t *testing.T) { db := &recordingDB{row: publicationValidationRow{}} context, err := NewStore(db).LoadPublicationForValidation(context.Background(), "publication-1") if err != nil { t.Fatalf("LoadPublicationForValidation() error = %v", err) } if context.ID != "publication-1" || context.TestKBID != "kb-1" || context.KnowledgeID != "knowledge-1" { t.Fatalf("validation context = %#v", context) } if db.queryRowSQL != loadPublicationForValidationSQL || len(db.queryRowArgs) != 1 || db.queryRowArgs[0] != "publication-1" { t.Fatalf("query = %q %#v", db.queryRowSQL, db.queryRowArgs) } } func TestListLegacyVerificationCandidatesMapsKnowledgeIDs(t *testing.T) { rows := &legacyVerificationRows{items: []legacyVerificationRow{ {id: "pub-1", kbID: "kb-1", knowledgeID: "knowledge-1"}, {id: "pub-2", kbID: "kb-2", knowledgeID: "knowledge-2"}, }} db := &recordingDB{rows: rows} candidates, err := NewStore(db).ListLegacyVerificationCandidates(context.Background()) if err != nil { t.Fatalf("ListLegacyVerificationCandidates() error = %v", err) } if len(candidates) != 2 || candidates[0].ID != "pub-1" || candidates[0].KnowledgeID != "knowledge-1" || candidates[1].TestKBID != "kb-2" { t.Fatalf("candidates = %#v", candidates) } if db.querySQL != listLegacyVerificationCandidatesSQL { t.Fatalf("query = %q", db.querySQL) } if !strings.Contains(listLegacyVerificationCandidatesSQL, "source_type = 'pp'") { t.Fatal("legacy verification candidates must exclude manual and future source types") } } func TestListTestPublicationsReturnsSafeProjection(t *testing.T) { now := time.Date(2026, time.September, 4, 5, 0, 0, 0, time.UTC) rows := &testPublicationRows{items: []testPublicationRow{ {id: "pub-1", title: "Safe title", ingest: "uploaded", processing: string(governance.ProcessingFailed), retrieval: "unpublished", targetScope: "external", changeSetID: "cs-1", changeType: "updated", canStart: false, retryCount: 2, lastError: "remote_parse_failed", canRetry: true, updated: now}, }} db := &recordingDB{rows: rows, row: totalRow{total: 1}} filter := governance.TestPublicationFilter{ProcessingState: string(governance.ProcessingFailed), Limit: 25, Offset: 0} page, err := NewStore(db).ListTestPublications(context.Background(), filter) if err != nil { t.Fatalf("ListTestPublications() error = %v", err) } if page.Total != 1 || len(page.Items) != 1 { t.Fatalf("page = %#v", page) } item := page.Items[0] if item.ID != "pub-1" || item.Title != "Safe title" || item.TargetScope != "external" || item.ChangeSetID != "cs-1" || item.ChangeType != "updated" || item.CanStart || item.ProcessingState != string(governance.ProcessingFailed) || item.RetryCount != 2 || item.LastError != "remote_parse_failed" || !item.CanRetry { t.Fatalf("item = %#v", item) } if db.queryRowSQL != countTestPublicationsSQL || db.querySQL != listTestPublicationsSQL { t.Fatalf("count = %q list = %q", db.queryRowSQL, db.querySQL) } } func TestListAcceptanceResultsMapsSafeProjection(t *testing.T) { now := time.Date(2026, time.September, 4, 5, 5, 0, 0, time.UTC) rows := &acceptanceRecordRows{items: []acceptanceRecordRow{ {checkType: "chunks_present", state: "passed", policy: "structural-v1", evidence: json.RawMessage(`{"chunk_total":2}`), observed: now}, }} db := &recordingDB{rows: rows} results, err := NewStore(db).ListAcceptanceResults(context.Background(), "publication-1") if err != nil { t.Fatalf("ListAcceptanceResults() error = %v", err) } if len(results) != 1 || results[0].CheckType != "chunks_present" || results[0].State != "passed" || string(results[0].EvidenceSummary) != `{"chunk_total":2}` { t.Fatalf("results = %#v", results) } if db.querySQL != listAcceptanceResultsSQL || len(db.queryArgs) != 1 || db.queryArgs[0] != "publication-1" { t.Fatalf("query = %q %#v", db.querySQL, db.queryArgs) } } func TestRetryPublicationResetsAndEnqueuesUploadJob(t *testing.T) { now := time.Date(2026, time.September, 4, 5, 10, 0, 0, time.UTC) db := &recordingDB{ row: retryStateRow{processing: "failed", ingest: "uploaded", spoolAvailable: true}, commandTag: pgconn.NewCommandTag("INSERT 0 1"), } if err := NewStore(db).RetryPublication(context.Background(), "publication-1", now); err != nil { t.Fatalf("RetryPublication() error = %v", err) } if db.queryRowSQL != loadRetryStateSQL || db.execSQL != retryPublicationSQL { t.Fatalf("query = %q exec = %q", db.queryRowSQL, db.execSQL) } if len(db.execArgs) != 4 || db.execArgs[0] != "publication-1" { t.Fatalf("exec args = %#v", db.execArgs) } } func TestRetryPublicationRecoversLegacyUploadFailedState(t *testing.T) { now := time.Date(2026, time.September, 5, 5, 30, 0, 0, time.UTC) db := &recordingDB{ row: retryStateRow{processing: "pending", ingest: "failed", spoolAvailable: true}, commandTag: pgconn.NewCommandTag("INSERT 0 1"), } if err := NewStore(db).RetryPublication(context.Background(), "publication-1", now); err != nil { t.Fatalf("RetryPublication() legacy upload failure error = %v", err) } if !strings.Contains(retryPublicationSQL, "ingest_state = 'failed'") { t.Fatal("retry SQL must recover legacy upload-failed state") } } func TestRetryPublicationRejectsCompleted(t *testing.T) { db := &recordingDB{row: retryStateRow{processing: "completed", ingest: "uploaded", spoolAvailable: true}} err := NewStore(db).RetryPublication(context.Background(), "publication-1", time.Date(2026, time.September, 4, 5, 11, 0, 0, time.UTC)) if !errors.Is(err, ErrPublicationStateConflict) { t.Fatalf("RetryPublication() error = %v, want state conflict", err) } if db.execSQL != "" { t.Fatal("completed publication reached the retry UPDATE") } } func TestRetryPublicationRejectsMissingSpool(t *testing.T) { db := &recordingDB{row: retryStateRow{processing: "failed", ingest: "uploaded", spoolAvailable: false}} err := NewStore(db).RetryPublication(context.Background(), "publication-1", time.Date(2026, time.September, 4, 5, 12, 0, 0, time.UTC)) if !errors.Is(err, ErrPublicationNotRetryable) { t.Fatalf("RetryPublication() error = %v, want not retryable", err) } } func TestMarkStalledRechecksNoProgressCutoffInDatabase(t *testing.T) { now := time.Date(2026, time.September, 4, 2, 10, 0, 0, time.UTC) cutoff := now.Add(-30 * time.Minute) db := &recordingDB{commandTag: pgconn.NewCommandTag("UPDATE 1")} if err := NewStore(db).MarkStalled(context.Background(), "publication-1", 3, cutoff, now); err != nil { t.Fatalf("MarkStalled() error = %v", err) } if db.execSQL != markStalledSQL || !strings.Contains(markStalledSQL, "updated_at <= $3") { t.Fatalf("stalled SQL = %q", db.execSQL) } staleDB := &recordingDB{commandTag: pgconn.NewCommandTag("UPDATE 0")} if err := NewStore(staleDB).MarkStalled(context.Background(), "publication-1", 3, cutoff, now); !errors.Is(err, ErrPublicationStateConflict) { t.Fatalf("MarkStalled() stale error = %v", err) } } func TestAppendAcceptanceResultValidatesAndAppendsEvidence(t *testing.T) { now := time.Date(2026, time.September, 4, 2, 11, 0, 0, time.UTC) result := governance.AcceptanceResult{ ID: "acceptance-1", PublicationID: "publication-1", RunID: "run-1", CheckType: "chunk_structure", State: governance.AcceptancePassed, PolicyVersion: "structural-v1", EvidenceSummary: json.RawMessage(`{"chunk_total":2,"parent_match":true}`), ObservedAt: now, } db := &recordingDB{commandTag: pgconn.NewCommandTag("INSERT 0 1")} if err := NewStore(db).AppendAcceptanceResult(context.Background(), result); err != nil { t.Fatalf("AppendAcceptanceResult() error = %v", err) } if db.execSQL != appendAcceptanceResultSQL || len(db.execArgs) != 8 { t.Fatalf("acceptance insert = %q %#v", db.execSQL, db.execArgs) } result.EvidenceSummary = json.RawMessage(`"raw text"`) invalidDB := &recordingDB{commandTag: pgconn.NewCommandTag("INSERT 0 1")} if err := NewStore(invalidDB).AppendAcceptanceResult(context.Background(), result); !errors.Is(err, ErrInvalidAcceptanceResult) { t.Fatalf("invalid acceptance error = %v", err) } if invalidDB.execSQL != "" { t.Fatal("invalid acceptance result reached database") } } type publicationUploadRow struct{} type publicationValidationRow struct{} func (publicationValidationRow) Scan(dest ...any) error { *(dest[0].(*string)) = "publication-1" *(dest[1].(*string)) = "kb-1" *(dest[2].(*string)) = "knowledge-1" return nil } type legacyVerificationRow struct { id string kbID string knowledgeID string } func (row legacyVerificationRow) Scan(dest ...any) error { *(dest[0].(*string)) = row.id *(dest[1].(*string)) = row.kbID *(dest[2].(*string)) = row.knowledgeID return nil } type legacyVerificationRows struct { items []legacyVerificationRow index int } func (rows *legacyVerificationRows) Close() {} func (rows *legacyVerificationRows) Err() error { return nil } func (rows *legacyVerificationRows) CommandTag() pgconn.CommandTag { return pgconn.CommandTag{} } func (rows *legacyVerificationRows) FieldDescriptions() []pgconn.FieldDescription { return nil } func (rows *legacyVerificationRows) Next() bool { if rows.index >= len(rows.items) { return false } rows.index++ return true } func (rows *legacyVerificationRows) Scan(dest ...any) error { return rows.items[rows.index-1].Scan(dest...) } func (rows *legacyVerificationRows) Values() ([]any, error) { return nil, errors.New("not implemented") } func (rows *legacyVerificationRows) RawValues() [][]byte { return nil } func (rows *legacyVerificationRows) Conn() *pgx.Conn { return nil } type testPublicationRow struct { id string title string ingest string processing string retrieval string targetScope string changeSetID string changeType string canStart bool retryCount int lastError string canRetry bool updated time.Time } func (row testPublicationRow) Scan(dest ...any) error { *(dest[0].(*string)) = row.id *(dest[1].(*string)) = row.title *(dest[2].(*string)) = row.ingest *(dest[3].(*string)) = row.processing *(dest[4].(*string)) = row.retrieval *(dest[5].(*string)) = row.targetScope *(dest[6].(*string)) = row.changeSetID *(dest[7].(*string)) = row.changeType *(dest[8].(*bool)) = row.canStart *(dest[9].(*int)) = row.retryCount *(dest[10].(*string)) = row.lastError *(dest[11].(*bool)) = row.canRetry *(dest[12].(*time.Time)) = row.updated return nil } type testPublicationRows struct { items []testPublicationRow index int } func (rows *testPublicationRows) Close() {} func (rows *testPublicationRows) Err() error { return nil } func (rows *testPublicationRows) CommandTag() pgconn.CommandTag { return pgconn.CommandTag{} } func (rows *testPublicationRows) FieldDescriptions() []pgconn.FieldDescription { return nil } func (rows *testPublicationRows) Next() bool { if rows.index >= len(rows.items) { return false } rows.index++ return true } func (rows *testPublicationRows) Scan(dest ...any) error { return rows.items[rows.index-1].Scan(dest...) } func (rows *testPublicationRows) Values() ([]any, error) { return nil, errors.New("not implemented") } func (rows *testPublicationRows) RawValues() [][]byte { return nil } func (rows *testPublicationRows) Conn() *pgx.Conn { return nil } type totalRow struct { total int } func (row totalRow) Scan(dest ...any) error { *(dest[0].(*int)) = row.total return nil } type acceptanceRecordRow struct { checkType string state string policy string evidence json.RawMessage observed time.Time } func (row acceptanceRecordRow) Scan(dest ...any) error { *(dest[0].(*string)) = row.checkType *(dest[1].(*string)) = row.state *(dest[2].(*string)) = row.policy *(dest[3].(*json.RawMessage)) = row.evidence *(dest[4].(*time.Time)) = row.observed return nil } type acceptanceRecordRows struct { items []acceptanceRecordRow index int } func (rows *acceptanceRecordRows) Close() {} func (rows *acceptanceRecordRows) Err() error { return nil } func (rows *acceptanceRecordRows) CommandTag() pgconn.CommandTag { return pgconn.CommandTag{} } func (rows *acceptanceRecordRows) FieldDescriptions() []pgconn.FieldDescription { return nil } func (rows *acceptanceRecordRows) Next() bool { if rows.index >= len(rows.items) { return false } rows.index++ return true } func (rows *acceptanceRecordRows) Scan(dest ...any) error { return rows.items[rows.index-1].Scan(dest...) } func (rows *acceptanceRecordRows) Values() ([]any, error) { return nil, errors.New("not implemented") } func (rows *acceptanceRecordRows) RawValues() [][]byte { return nil } func (rows *acceptanceRecordRows) Conn() *pgx.Conn { return nil } type retryStateRow struct { processing string ingest string spoolAvailable bool } func (row retryStateRow) Scan(dest ...any) error { *(dest[0].(*string)) = row.processing *(dest[1].(*string)) = row.ingest *(dest[2].(*bool)) = row.spoolAvailable return nil } type publicationPollRow struct { now time.Time } func (row publicationPollRow) Scan(dest ...any) error { *(dest[0].(*string)) = "publication-1" *(dest[1].(*string)) = "kb-1" *(dest[2].(*string)) = "knowledge-1" *(dest[3].(*string)) = string(governance.ProcessingProcessing) *(dest[4].(*int)) = 2 *(dest[5].(*string)) = "processing" *(dest[6].(**time.Time)) = &row.now *(dest[7].(**time.Time)) = &row.now *(dest[8].(**time.Time)) = &row.now *(dest[9].(**time.Time)) = &row.now return nil } type sequenceRow struct { sequence int } func (row sequenceRow) Scan(dest ...any) error { *(dest[0].(*int)) = row.sequence return nil } func (publicationUploadRow) Scan(dest ...any) error { values := []any{ "publication-1", "version-1", "kb-1", "", string(governance.IngestPending), string(governance.ProcessingPending), "internal", "content-1", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", int64(24), "text/markdown", "md", "objects/artifact.md", "Safe title", } for index, value := range values { switch target := dest[index].(type) { case *string: *target = value.(string) case *int64: *target = value.(int64) case *governance.Visibility: *target = governance.Visibility(value.(string)) case nil: panic("nil destination") default: panic("unexpected scan destination") } } return nil }