[#99] Link layout entries to analyzed serialized files; document layout-only NULLs

Author: SkowronskiAndrew

Analyzer/SQLite/Parsers/ContentLayoutParser.cs

@@ -72,8 +72,14 @@ private static void Fail(string message)
             throw new Exception(message);
         }
 
+        // Called after all files are processed, so the analyzed .cf files all have their
+        // serialized_files rows and the layout entries can be linked to them.
         public void FinalizeDatabase()
         {
+            if (m_ImportedLayout != null)
+            {
+                m_Writer.LinkSerializedFiles();
+            }
         }
 
         public void Dispose()

Analyzer/SQLite/Writers/ContentLayoutSQLWriter.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.IO;
 using Microsoft.Data.Sqlite;
 using UnityDataTools.Analyzer.SQLite.Commands.ContentLayout;
 using UnityDataTools.Models;
@@ -27,6 +28,9 @@ internal class ContentLayoutSQLWriter : IDisposable
         private bool m_Initialized;
         private SqliteConnection m_Database;
 
+        // The layout files that can have a .cf file on disk, kept for LinkSerializedFiles.
+        private List<(int Index, string ContentHash)> m_ImportedFiles = new();
+
         public ContentLayoutSQLWriter(SqliteConnection database)
         {
             m_Database = database;
@@ -75,10 +79,16 @@ public void WriteContentLayout(string filename, ContentLayout layout)
                     m_AddSerializedFile.SetValue("is_builtin", file.IsBuiltIn ? 1 : 0);
                     m_AddSerializedFile.SetValue("content_hash",
                         string.IsNullOrEmpty(file.ContentHash) ? null : file.ContentHash);
-                    // Filled in when the analyzed input also contains the build content.
+                    // Filled in by LinkSerializedFiles when the analyzed input also contains the
+                    // build content.
                     m_AddSerializedFile.SetValue("serialized_file", null);
                     m_AddSerializedFile.ExecuteNonQuery();
 
+                    if (!string.IsNullOrEmpty(file.ContentHash))
+                    {
+                        m_ImportedFiles.Add((file.Index, file.ContentHash));
+                    }
+
                     // Empty arrays can be omitted from the json, leaving the fields null.
                     foreach (var assetPath in file.SourceAssets ?? [])
                     {
@@ -166,6 +176,52 @@ public void WriteContentLayout(string filename, ContentLayout layout)
             ExecuteDDL(Properties.Resources.ContentLayoutIndexes);
         }
 
+        // Fills in the serialized_file column, linking each layout entry to the serialized_files
+        // row of its analyzed .cf file. Called after all files are processed; entries whose file
+        // was not part of the analyzed input (e.g. a layout-only analyze) stay NULL. The match is
+        // on the file name (the content hash), ignoring any directory part that the analyze pass
+        // recorded in serialized_files.name.
+        public void LinkSerializedFiles()
+        {
+            var fileNameToId = new Dictionary<string, int>();
+            using (var select = m_Database.CreateCommand())
+            {
+                select.CommandText = "SELECT id, name FROM serialized_files";
+                using var reader = select.ExecuteReader();
+                while (reader.Read())
+                {
+                    fileNameToId[Path.GetFileName(reader.GetString(1)).ToLowerInvariant()] = reader.GetInt32(0);
+                }
+            }
+
+            using var transaction = m_Database.BeginTransaction();
+            using var update = m_Database.CreateCommand();
+            update.Transaction = transaction;
+            update.CommandText = "UPDATE content_layout_serialized_files SET serialized_file = @id WHERE file_index = @file_index";
+            update.Parameters.Add("@id", SqliteType.Integer);
+            update.Parameters.Add("@file_index", SqliteType.Integer);
+
+            try
+            {
+                foreach (var file in m_ImportedFiles)
+                {
+                    if (fileNameToId.TryGetValue(file.ContentHash + ".cf", out var id))
+                    {
+                        update.Parameters["@id"].Value = id;
+                        update.Parameters["@file_index"].Value = file.Index;
+                        update.ExecuteNonQuery();
+                    }
+                }
+
+                transaction.Commit();
+            }
+            catch (Exception)
+            {
+                transaction.Rollback();
+                throw;
+            }
+        }
+
         private void SetTransaction(SqliteTransaction transaction)
         {
             m_AddContentLayout.SetTransaction(transaction);

Documentation/analyzer.md

@@ -295,8 +295,8 @@ top-level `RootAssets` list folded into the `is_root_asset` flag:
 * `content_layout_serialized_files`: one row per serialized file (.cf Content File) of the build,
   keyed by `file_index` (the json array index). Records the symbolic `cfid`, `is_builtin`, and the
   `content_hash` that gives the filename (`content_hash || '.cf'`). The `serialized_file` column
-  references the core `serialized_files` table when the build content is part of the analyzed
-  input, connecting the layout to the analyzed objects.
+  references the core `serialized_files` table, connecting the layout to the analyzed objects
+  (see [Analyzing the layout with or without the build content](#analyzing-the-layout-with-or-without-the-build-content)).
 * `content_layout_source_assets`: the source assets included in each serialized file.
 * `content_layout_serialized_file_dependencies`: file-to-file dependency edges. The 1-based
   `position` column preserves the json array order, which is how PPtr `m_FileID` values resolve
@@ -323,6 +323,23 @@ filenames), `content_layout_loadable_objects_view` (loadables resolved to their
 SELECT * FROM content_layout_source_assets_view WHERE asset_path = 'Assets/Textures/GreenStatic.png';
 ```
 
+### Analyzing the layout with or without the build content
+
+A `ContentLayout.json` can be analyzed on its own — useful for running SQL queries against a large
+layout — or together with the build output it describes. The layout tables themselves are
+identical in both cases; what differs is the connection to the core tables:
+
+* When the build content is part of the analyzed input, each `content_layout_serialized_files`
+  row is linked to its analyzed file through the `serialized_file` column, and the views resolve
+  across that link (e.g. `content_layout_loadable_objects_view` shows the object, type, name and
+  size of each loadable).
+* In a layout-only analyze there is nothing to link to, so expect NULL in
+  `content_layout_serialized_files.serialized_file`, in the `archive` column of
+  `content_layout_serialized_files_view`, and in the `object`, `type`, `name` and `size` columns
+  of `content_layout_loadable_objects_view`. Built-in entries (`is_builtin = 1`) additionally
+  always have a NULL `content_hash` and `serialized_file` - they are not files produced by the
+  build.
+
 ## BuildReport
 
 See [BuildReport.md](buildreport.md) for details of the tables and views related to analyzing BuildReport files.