simplify DB schema by encoding unconditional conformances separately from conditional conformances

Author: tayloraswift

Sources/UnidocLinker/Sema/Unidoc.Conformers.swift

@@ -1,40 +1,57 @@
+import Signatures
 import UnidocRecords
 
 extension Unidoc
 {
     struct Conformers:Identifiable
     {
         let id:LinkerIndex<Self>
-        var list:[ConformingType]
 
         private
-        init(id:LinkerIndex<Self>, list:[ConformingType])
+        var unconditional:[Unidoc.Scalar]
+        private
+        var conditional:[ConformingType]
+
+        init(id:LinkerIndex<Self>)
         {
             self.id = id
-            self.list = list
+            self.unconditional = []
+            self.conditional = []
         }
     }
 }
+extension Unidoc.Conformers
+{
+    mutating
+    func append(conformer type:Unidoc.Scalar,
+        where constraints:[GenericConstraint<Unidoc.Scalar?>])
+    {
+        constraints.isEmpty
+            ? self.unconditional.append(type)
+            : self.conditional.append(.init(id: type, where: constraints))
+    }
+}
 extension Unidoc.Conformers:Unidoc.LinkerIndexable
 {
     typealias Signature = Unidoc.ConformanceSignature
 
     static
     var type:Unidoc.GroupType { .conformers }
 
-    init(id:Unidoc.LinkerIndex<Self>)
+    var isEmpty:Bool
     {
-        self.init(id: id, list: [])
+        self.unconditional.isEmpty && self.conditional.isEmpty
     }
 
-    var isEmpty:Bool { self.list.isEmpty }
-
+    __consuming
     func assemble(signature:Unidoc.ConformanceSignature,
         with linker:borrowing Unidoc.Linker) -> Unidoc.ConformerGroup
     {
         .init(id: self.id.in(linker.current.id),
             culture: linker.current.id + signature.culture,
             scope: signature.conformance,
-            types: self.list) // do we need to sort this?
+            unconditional: self.unconditional,
+            conditional: self.conditional)
+            // do we need to sort this?
     }
 }

Sources/UnidocLinker/Sema/Unidoc.Extension.swift

@@ -23,24 +23,17 @@ extension Unidoc
         var overview:Unidoc.Passage?
         var details:Unidoc.Passage?
 
-        private
-        init(id:LinkerIndex<Self>,
-            conformances:[Unidoc.Scalar],
-            features:[Unidoc.Scalar],
-            nested:[Unidoc.Scalar],
-            subforms:[Unidoc.Scalar],
-            overview:Unidoc.Passage? ,
-            details:Unidoc.Passage? )
+        init(id:LinkerIndex<Self>)
         {
             self.id = id
 
-            self.conformances = conformances
-            self.features = features
-            self.nested = nested
-            self.subforms = subforms
+            self.conformances = []
+            self.features = []
+            self.nested = []
+            self.subforms = []
 
-            self.overview = overview
-            self.details = details
+            self.overview = nil
+            self.details = nil
         }
     }
 }
@@ -51,17 +44,6 @@ extension Unidoc.Extension:Unidoc.LinkerIndexable
     static
     var type:Unidoc.GroupType { .extension }
 
-    init(id:Unidoc.LinkerIndex<Self>)
-    {
-        self.init(id: id,
-            conformances: [],
-            features: [],
-            nested: [],
-            subforms: [],
-            overview: nil,
-            details: nil)
-    }
-
     var isEmpty:Bool
     {
         self.conformances.isEmpty &&
@@ -72,6 +54,7 @@ extension Unidoc.Extension:Unidoc.LinkerIndexable
         self.details == nil
     }
 
+    __consuming
     func assemble(signature:Unidoc.ExtensionSignature,
         with linker:borrowing Unidoc.Linker) -> Unidoc.ExtensionGroup
     {

Sources/UnidocLinker/Sema/Unidoc.Linker.Table.swift

@@ -72,8 +72,8 @@ extension Unidoc.Linker.Table<Unidoc.Conformers>
         {
             for condition:Unidoc.ExtensionConditions in conditions
             {
-                self[.conforms(to: p, in: condition.culture)].list.append(.init(id: type,
-                    where: condition.constraints))
+                self[.conforms(to: p, in: condition.culture)].append(conformer: type,
+                    where: condition.constraints)
             }
         }
     }

Sources/UnidocLinker/Sema/Unidoc.LinkerIndexable.swift

@@ -14,5 +14,6 @@ protocol _UnidocLinkerIndexable:Identifiable<Unidoc.LinkerIndex<Self>>
 
     var isEmpty:Bool { get }
 
+    consuming
     func assemble(signature:Signature, with linker:borrowing Unidoc.Linker) -> Assembled
 }

Sources/UnidocQueries/Volumes/Unidoc.ConformingType (ext).swift

@@ -0,0 +1,5 @@
+import MongoQL
+
+extension Unidoc.ConformingType:MongoMasterCodingModel
+{
+}

Sources/UnidocQueries/Volumes/Unidoc.ConformingType.Conditional (ext).swift

@@ -66,9 +66,12 @@ extension Unidoc.AnyGroup
         /// which are, of course, scalars.
         case members = "t"
 
+        /// Optional and appears in ``ConformingTypesGroup`` only.
+        /// The field contains a list of scalars.
+        case unconditional = "u"
         /// Optional and appears in ``ConformingTypesGroup`` only.
         /// The field contains a list of conforming types, which contain scalars.
-        case types = "k"
+        case conditional = "k"
 
         /// Contains a list of precomputed zones, as MongoDB cannot easily
         /// convert scalars to zones. This field will be computed and
@@ -119,11 +122,12 @@ extension Unidoc.AnyGroup:BSONDocumentEncodable
             bson[.culture] = self.culture
             bson[.scope] = self.scope
 
-            //  This is the only array field and there is no reason why it would ever be empty.
-            bson[.types] = self.types
+            bson[.unconditional] = self.unconditional.isEmpty ? nil : self.unconditional
+            bson[.conditional] = self.conditional.isEmpty ? nil : self.conditional
 
             zones.update(with: self.culture.edition)
-            zones.update(with: self.types)
+            zones.update(with: self.unconditional)
+            zones.update(with: self.conditional)
 
         case .extension(let self):
             bson[.constraints] = self.constraints.isEmpty ? nil : self.constraints
@@ -186,7 +190,8 @@ extension Unidoc.AnyGroup:BSONDocumentDecodable
             self = .conformers(.init(id: id,
                 culture: try bson[.culture].decode(),
                 scope: try bson[.scope].decode(),
-                types: try bson[.types].decode()))
+                unconditional: try bson[.unconditional]?.decode() ?? [],
+                conditional: try bson[.conditional]?.decode() ?? []))
 
         case .extension?:
             self = .extension(.init(id: id,

Sources/UnidocRecords/Volumes/Groups/Unidoc.AnyGroup.swift

@@ -14,15 +14,22 @@ extension Unidoc
         let scope:Scalar
 
         public
-        var types:[ConformingType]
+        var unconditional:[Unidoc.Scalar]
+        public
+        var conditional:[ConformingType]
 
         @inlinable public
-        init(id:Group, culture:Scalar, scope:Scalar, types:[ConformingType] = [])
+        init(id:Group,
+            culture:Scalar,
+            scope:Scalar,
+            unconditional:[Unidoc.Scalar] = [],
+            conditional:[ConformingType] = [])
         {
             self.id = id
             self.culture = culture
             self.scope = scope
-            self.types = types
+            self.unconditional = unconditional
+            self.conditional = conditional
         }
     }
 }

Sources/UnidocRecords/Volumes/Groups/Unidoc.ConformerGroup.swift

@@ -1,5 +1,6 @@
 import BSON
 import Signatures
+import SymbolGraphs
 
 extension Unidoc
 {
@@ -21,40 +22,28 @@ extension Unidoc
 }
 extension Unidoc.ConformingType
 {
-    @inlinable
-    var conditional:Conditional?
+    @frozen public
+    enum CodingKey:String, Sendable
     {
-        self.constraints.isEmpty ? nil : .init(id: self.id, where: self.constraints)
+        case id = "i"
+        //  Non-optional, because we expect to encode unconditional conformances separately.
+        case constraints = "g"
     }
 }
-extension Unidoc.ConformingType:BSONEncodable
+extension Unidoc.ConformingType:BSONDocumentEncodable
 {
-    @inlinable public
-    func encode(to field:inout BSON.FieldEncoder)
+    public
+    func encode(to bson:inout BSON.DocumentEncoder<CodingKey>)
     {
-        if  let conditional:Conditional = self.conditional
-        {
-            conditional.encode(to: &field)
-        }
-        else
-        {
-            self.id.encode(to: &field)
-        }
+        bson[.id] = self.id
+        bson[.constraints] = self.constraints
     }
 }
-extension Unidoc.ConformingType:BSONDecodable
+extension Unidoc.ConformingType:BSONDocumentDecodable
 {
     @inlinable public
-    init(bson:BSON.AnyValue<some RandomAccessCollection<UInt8>>) throws
+    init(bson:BSON.DocumentDecoder<CodingKey, some RandomAccessCollection<UInt8>>) throws
     {
-        if  case .id(let id) = bson
-        {
-            self.init(id: Unidoc.Scalar.init(id))
-        }
-        else
-        {
-            let conditional:Conditional = try .init(bson: bson)
-            self.init(id: conditional.id, where: conditional.constraints)
-        }
+        self.init(id: try bson[.id].decode(), where: try bson[.constraints].decode())
     }
 }