naturally, we were working on the wrong code

tayloraswift · tayloraswift · commit e98566ca1c90 · 2024-09-29T05:06:00.000Z
diff --git a/Sources/UnidocDB/Vertices/Unidoc.DB.Redirects.swift b/Sources/UnidocDB/Vertices/Unidoc.DB.Redirects.swift
@@ -28,9 +28,9 @@ extension Unidoc.DB.Redirects
         collation: VolumeCollation.spec,
         unique: true)
     {
-        $0[Element[.id] / Unidoc.Redirect[.volume]] = (+)
-        $0[Element[.stem]] = (+)
-        $0[Element[.hash]] = (+)
+        $0[Element[.id] / Unidoc.RedirectSource[.volume]] = (+)
+        $0[Element[.id] / Unidoc.RedirectSource[.stem]] = (+)
+        $0[Element[.id] / Unidoc.RedirectSource[.hash]] = (+)
     }
 }
 extension Unidoc.DB.Redirects:Mongo.CollectionModel
@@ -54,7 +54,7 @@ extension Unidoc.DB.Redirects
     {
         try await self.deleteAll
         {
-            $0[Element[.id] / Unidoc.Redirect[.volume]] = volume
+            $0[Element[.id] / Unidoc.RedirectSource[.volume]] = volume
         }
     }
 }
diff --git a/Sources/UnidocDB/Vertices/Unidoc.Redirect (ext).swift b/Sources/UnidocDB/Vertices/Unidoc.Redirect (ext).swift
diff --git a/Sources/UnidocDB/Vertices/Unidoc.RedirectSource (ext).swift b/Sources/UnidocDB/Vertices/Unidoc.RedirectSource (ext).swift
@@ -0,0 +1,6 @@
+import MongoQL
+import UnidocRecords
+
+extension Unidoc.RedirectSource:Mongo.MasterCodingModel
+{
+}
diff --git a/Sources/UnidocLinker/Sema/Unidoc.Linker.Tables.swift b/Sources/UnidocLinker/Sema/Unidoc.Linker.Tables.swift
@@ -36,7 +36,6 @@ extension Unidoc.Linker
 
         private(set)
         var extensions:Unidoc.Linker.Table<Unidoc.Extension>
-        var redirects:[Unidoc.RedirectVertex]
         var articles:[Unidoc.ArticleVertex]
         var decls:[Unidoc.DeclVertex]
 
@@ -60,7 +59,6 @@ extension Unidoc.Linker
             self.next = .init(base: self.context.current.id)
 
             self.extensions = extensions
-            self.redirects = []
             self.articles = []
             self.decls = []
 
@@ -390,10 +388,6 @@ extension Unidoc.Linker.Tables
             {
                 self.link(articles: articles, under: namespace)
             }
-
-            //  Create redirects
-            self.redirect(decls: culture.reexports.unhashed, hashed: false, from: namespace)
-            self.redirect(decls: culture.reexports.hashed, hashed: true, from: namespace)
         }
 
         return self.modules.map
@@ -554,32 +548,4 @@ extension Unidoc.Linker.Tables
 
         return miscellaneous
     }
-
-    private mutating
-    func redirect(decls:[Int32],
-        hashed:Bool,
-        from namespace:SymbolGraph.NamespaceContext<Void>)
-    {
-        for local:Int32 in decls
-        {
-            let symbol:Symbol.Decl = self.current.decls.symbols[local]
-
-            guard
-            let id:Unidoc.Scalar = self.current.scalars.decls[local],
-            let decl:SymbolGraph.Decl = self.context[decl: id]
-            else
-            {
-                continue
-            }
-
-            let redirect:Unidoc.RedirectVertex = .init(id: .init(
-                    volume: self.current.id,
-                    target: id),
-                stem: .decl(namespace.module, decl.path, decl.phylum),
-                hash: .decl(symbol),
-                hashed: hashed)
-
-            self.redirects.append(redirect)
-        }
-    }
 }
diff --git a/Sources/UnidocLinker/Sema/Unidoc.LinkerTables.swift b/Sources/UnidocLinker/Sema/Unidoc.LinkerTables.swift
@@ -379,6 +379,52 @@ extension Unidoc.LinkerTables
             return vertex
         }
     }
+
+    func linkRedirects() -> [Unidoc.RedirectVertex]
+    {
+        self.modules.reduce(into: [])
+        {
+            for (decls, hashed):([Int32], Bool) in [
+                ($1.culture.reexports.unhashed, false),
+                ($1.culture.reexports.hashed, true),
+            ]
+            {
+                for target:Int32 in decls
+                {
+                    if  let vertex:Unidoc.RedirectVertex = self.linkRedirect(
+                        target: target,
+                        hashed: hashed,
+                        from: $1.symbol)
+                    {
+                        $0.append(vertex)
+                    }
+                }
+            }
+        }
+    }
+
+    private
+    func linkRedirect(
+        target local:Int32,
+        hashed:Bool,
+        from namespace:Symbol.Module) -> Unidoc.RedirectVertex?
+    {
+        let symbol:Symbol.Decl = self.current.decls.symbols[local]
+
+        guard
+        let id:Unidoc.Scalar = self.current.scalars.decls[local],
+        let decl:SymbolGraph.Decl = self.linker[decl: id]
+        else
+        {
+            return nil
+        }
+
+        return .init(id: .init(volume: self.current.id,
+                stem: .decl(namespace, decl.path, decl.phylum),
+                hash: .decl(symbol)),
+            target: id,
+            hashed: hashed)
+    }
 }
 extension Unidoc.LinkerTables
 {
diff --git a/Sources/UnidocLinker/Unidoc.Mesh.Interior.swift b/Sources/UnidocLinker/Unidoc.Mesh.Interior.swift
@@ -88,7 +88,7 @@ extension Unidoc.Mesh.Interior
             products = tables.linkProducts()
             cultures = tables.linkCultures()
 
-            redirects = tables.redirects
+            redirects = []
             articles = tables.articles
             decls = tables.decls
             groups = tables.groups
@@ -109,9 +109,9 @@ extension Unidoc.Mesh.Interior
             decls = tables.linkDecls()
             articles = tables.linkArticles()
             cultures = tables.linkCultures()
+            redirects = tables.linkRedirects()
 
             extensions = tables.extensions
-            redirects = []
             groups = tables.groups
 
             linker = tables.linker
diff --git a/Sources/UnidocQueries/Volumes/Unidoc.RedirectByExportQuery.swift b/Sources/UnidocQueries/Volumes/Unidoc.RedirectByExportQuery.swift
@@ -33,9 +33,9 @@ extension Unidoc.RedirectByExportQuery:Mongo.PipelineQuery
     {
         pipeline[stage: .match]
         {
-            $0[CollectionOrigin.Element[.id] / Unidoc.Redirect[.volume]] = self.volume
-            $0[CollectionOrigin.Element[.stem]] = self.stem
-            $0[CollectionOrigin.Element[.hash]] = self.hash
+            $0[CollectionOrigin.Element[.id] / Unidoc.RedirectSource[.volume]] = self.volume
+            $0[CollectionOrigin.Element[.id] / Unidoc.RedirectSource[.stem]] = self.stem
+            $0[CollectionOrigin.Element[.id] / Unidoc.RedirectSource[.hash]] = self.hash
         }
 
         pipeline[stage: .limit] = 1
@@ -62,7 +62,7 @@ extension Unidoc.RedirectByExportQuery:Mongo.PipelineQuery
         pipeline[stage: .lookup]
         {
             $0[.from] = Unidoc.DB.Vertices.name
-            $0[.localField] = CollectionOrigin.Element[.id] / Unidoc.Redirect[.target]
+            $0[.localField] = CollectionOrigin.Element[.target]
             $0[.foreignField] = Unidoc.AnyVertex[.id]
             $0[.as] = Iteration.BatchElement[.matches]
         }
diff --git a/Sources/UnidocRecords/Volumes/Vertices/Unidoc.Redirect.swift b/Sources/UnidocRecords/Volumes/Vertices/Unidoc.Redirect.swift
diff --git a/Sources/UnidocRecords/Volumes/Vertices/Unidoc.RedirectSource.swift b/Sources/UnidocRecords/Volumes/Vertices/Unidoc.RedirectSource.swift
@@ -0,0 +1,57 @@
+import FNV1
+import BSON
+import UnidocAPI
+
+extension Unidoc
+{
+    @frozen public
+    struct RedirectSource:Hashable, Sendable
+    {
+        public
+        let volume:Edition
+        public
+        let stem:Stem
+        /// We don’t have any reason to correlate redirects themselves across volumes.
+        /// Therefore, we store only the 24-bit hash, to simplify queries.
+        public
+        let hash:FNV24
+
+        @inlinable public
+        init(volume:Edition, stem:Stem, hash:FNV24)
+        {
+            self.volume = volume
+            self.stem = stem
+            self.hash = hash
+        }
+    }
+}
+extension Unidoc.RedirectSource
+{
+    @frozen public
+    enum CodingKey:String, Sendable
+    {
+        case volume = "V"
+        case stem = "U"
+        case hash = "H"
+    }
+}
+extension Unidoc.RedirectSource:BSONDocumentEncodable
+{
+    public
+    func encode(to document:inout BSON.DocumentEncoder<CodingKey>)
+    {
+        document[.volume] = self.volume
+        document[.stem] = self.stem
+        document[.hash] = self.hash
+    }
+}
+extension Unidoc.RedirectSource:BSONDocumentDecodable
+{
+    public
+    init(bson:BSON.DocumentDecoder<CodingKey>) throws
+    {
+        self.init(volume: try bson[.volume].decode(),
+            stem: try bson[.stem].decode(),
+            hash: try bson[.hash].decode())
+    }
+}
diff --git a/Sources/UnidocRecords/Volumes/Vertices/Unidoc.RedirectVertex.swift b/Sources/UnidocRecords/Volumes/Vertices/Unidoc.RedirectVertex.swift
@@ -8,22 +8,17 @@ extension Unidoc
     struct RedirectVertex:Identifiable
     {
         public
-        let id:Redirect
+        let id:RedirectSource
         public
-        let stem:Stem
-        /// We don’t have any reason to correlate redirects themselves across volumes.
-        /// Therefore, we store only the 24-bit hash, to simplify queries.
-        public
-        let hash:FNV24
+        let target:Scalar
         public
         let hashed:Bool
 
         @inlinable public
-        init(id:Redirect, stem:Stem, hash:FNV24, hashed:Bool)
+        init(id:RedirectSource, target:Scalar, hashed:Bool)
         {
             self.id = id
-            self.stem = stem
-            self.hash = hash
+            self.target = target
             self.hashed = hashed
         }
     }
@@ -34,8 +29,7 @@ extension Unidoc.RedirectVertex
     enum CodingKey:String, Sendable
     {
         case id = "_id"
-        case stem = "U"
-        case hash = "F"
+        case target = "T"
         case hashed = "H"
         /// The target volume, omitted in the schema if it matches the source volume. It is
         /// omitted because in that case, it can be computed from the target vertex coordinate.
@@ -48,12 +42,11 @@ extension Unidoc.RedirectVertex:BSONDocumentEncodable
     func encode(to document:inout BSON.DocumentEncoder<CodingKey>)
     {
         document[.id] = self.id
-        document[.stem] = self.stem
-        document[.hash] = self.hash
+        document[.target] = self.target
         document[.hashed] = self.hashed ? true : nil
 
-        document[.volume] = self.id.volume != self.id.target.edition
-            ? self.id.target.edition
+        document[.volume] = self.id.volume != self.target.edition
+            ? self.target.edition
             : nil
     }
 }
@@ -63,8 +56,7 @@ extension Unidoc.RedirectVertex:BSONDocumentDecodable
     init(bson:BSON.DocumentDecoder<CodingKey>) throws
     {
         self.init(id: try bson[.id].decode(),
-            stem: try bson[.stem].decode(),
-            hash: try bson[.hash].decode(),
+            target: try bson[.target].decode(),
             hashed: try bson[.hashed]?.decode() ?? false)
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -28,9 +28,9 @@ extension Unidoc.DB.Redirects`
`28`	`28`	`collation: VolumeCollation.spec,`
`29`	`29`	`unique: true)`
`30`	`30`	`{`
`31`		`- $0[Element[.id] / Unidoc.Redirect[.volume]] = (+)`
`32`		`- $0[Element[.stem]] = (+)`
`33`		`- $0[Element[.hash]] = (+)`
	`31`	`+ $0[Element[.id] / Unidoc.RedirectSource[.volume]] = (+)`
	`32`	`+ $0[Element[.id] / Unidoc.RedirectSource[.stem]] = (+)`
	`33`	`+ $0[Element[.id] / Unidoc.RedirectSource[.hash]] = (+)`
`34`	`34`	`}`
`35`	`35`	`}`
`36`	`36`	`extension Unidoc.DB.Redirects:Mongo.CollectionModel`
`@@ -54,7 +54,7 @@ extension Unidoc.DB.Redirects`
`54`	`54`	`{`
`55`	`55`	`try await self.deleteAll`
`56`	`56`	`{`
`57`		`- $0[Element[.id] / Unidoc.Redirect[.volume]] = volume`
	`57`	`+ $0[Element[.id] / Unidoc.RedirectSource[.volume]] = volume`
`58`	`58`	`}`
`59`	`59`	`}`
`60`	`60`	`}`
Original file line number	Diff line number	Diff line change
`@@ -33,9 +33,9 @@ extension Unidoc.RedirectByExportQuery:Mongo.PipelineQuery`
`33`	`33`	`{`
`34`	`34`	`pipeline[stage: .match]`
`35`	`35`	`{`
`36`		`- $0[CollectionOrigin.Element[.id] / Unidoc.Redirect[.volume]] = self.volume`
`37`		`- $0[CollectionOrigin.Element[.stem]] = self.stem`
`38`		`- $0[CollectionOrigin.Element[.hash]] = self.hash`
	`36`	`+ $0[CollectionOrigin.Element[.id] / Unidoc.RedirectSource[.volume]] = self.volume`
	`37`	`+ $0[CollectionOrigin.Element[.id] / Unidoc.RedirectSource[.stem]] = self.stem`
	`38`	`+ $0[CollectionOrigin.Element[.id] / Unidoc.RedirectSource[.hash]] = self.hash`
`39`	`39`	`}`
`40`	`40`
`41`	`41`	`pipeline[stage: .limit] = 1`
`@@ -62,7 +62,7 @@ extension Unidoc.RedirectByExportQuery:Mongo.PipelineQuery`
`62`	`62`	`pipeline[stage: .lookup]`
`63`	`63`	`{`
`64`	`64`	`$0[.from] = Unidoc.DB.Vertices.name`
`65`		`- $0[.localField] = CollectionOrigin.Element[.id] / Unidoc.Redirect[.target]`
	`65`	`+ $0[.localField] = CollectionOrigin.Element[.target]`
`66`	`66`	`$0[.foreignField] = Unidoc.AnyVertex[.id]`
`67`	`67`	`$0[.as] = Iteration.BatchElement[.matches]`
`68`	`68`	`}`
Original file line number	Diff line number	Diff line change
`@@ -8,22 +8,17 @@ extension Unidoc`
`8`	`8`	`struct RedirectVertex:Identifiable`
`9`	`9`	`{`
`10`	`10`	`public`
`11`		`- let id:Redirect`
	`11`	`+ let id:RedirectSource`
`12`	`12`	`public`
`13`		`- let stem:Stem`
`14`		`- /// We don’t have any reason to correlate redirects themselves across volumes.`
`15`		`- /// Therefore, we store only the 24-bit hash, to simplify queries.`
`16`		`- public`
`17`		`- let hash:FNV24`
	`13`	`+ let target:Scalar`
`18`	`14`	`public`
`19`	`15`	`let hashed:Bool`
`20`	`16`
`21`	`17`	`@inlinable public`
`22`		`- init(id:Redirect, stem:Stem, hash:FNV24, hashed:Bool)`
	`18`	`+ init(id:RedirectSource, target:Scalar, hashed:Bool)`
`23`	`19`	`{`
`24`	`20`	`self.id = id`
`25`		`- self.stem = stem`
`26`		`- self.hash = hash`
	`21`	`+ self.target = target`
`27`	`22`	`self.hashed = hashed`
`28`	`23`	`}`
`29`	`24`	`}`
`@@ -34,8 +29,7 @@ extension Unidoc.RedirectVertex`
`34`	`29`	`enum CodingKey:String, Sendable`
`35`	`30`	`{`
`36`	`31`	`case id = "_id"`
`37`		`- case stem = "U"`
`38`		`- case hash = "F"`
	`32`	`+ case target = "T"`
`39`	`33`	`case hashed = "H"`
`40`	`34`	`/// The target volume, omitted in the schema if it matches the source volume. It is`
`41`	`35`	`/// omitted because in that case, it can be computed from the target vertex coordinate.`
`@@ -48,12 +42,11 @@ extension Unidoc.RedirectVertex:BSONDocumentEncodable`
`48`	`42`	`func encode(to document:inout BSON.DocumentEncoder<CodingKey>)`
`49`	`43`	`{`
`50`	`44`	`document[.id] = self.id`
`51`		`- document[.stem] = self.stem`
`52`		`- document[.hash] = self.hash`
	`45`	`+ document[.target] = self.target`
`53`	`46`	`document[.hashed] = self.hashed ? true : nil`
`54`	`47`
`55`		`- document[.volume] = self.id.volume != self.id.target.edition`
`56`		`- ? self.id.target.edition`
	`48`	`+ document[.volume] = self.id.volume != self.target.edition`
	`49`	`+ ? self.target.edition`
`57`	`50`	`: nil`
`58`	`51`	`}`
`59`	`52`	`}`
`@@ -63,8 +56,7 @@ extension Unidoc.RedirectVertex:BSONDocumentDecodable`
`63`	`56`	`init(bson:BSON.DocumentDecoder<CodingKey>) throws`
`64`	`57`	`{`
`65`	`58`	`self.init(id: try bson[.id].decode(),`
`66`		`- stem: try bson[.stem].decode(),`
`67`		`- hash: try bson[.hash].decode(),`
	`59`	`+ target: try bson[.target].decode(),`
`68`	`60`	`hashed: try bson[.hashed]?.decode() ?? false)`
`69`	`61`	`}`
`70`	`62`	`}`