Improve Analyze documentation, small code fixes (#25)

Add a new topic to the documentation that gives some example usage of Analyze, for example to run queries on the command line.
Rework the README.md for Analyze library to move the more advanced developer focused information to the bottom. (I think most readers will just want to understand what Analyze does, and only more rare cases will they want to understand the implementation and actually extend library )
Add more details about how to extend the Analyze library to add support for more types.
Trivial code changes:

Remove dead code - SerializedObject base class is not used.
Fix two warnings about unreferenced variables.

Author: SkowronskiAndrew

Analyzer/PPtrAndCrcProcessor.cs

@@ -65,7 +65,7 @@ private UnityFileReader GetResourceReader(string filename)
                 {
                     reader = new UnityFileReader(Path.Join(m_Folder, filename), 4 * 1024 * 1024);
                 }
-                catch (Exception e)
+                catch (Exception)
                 {
                     Console.Error.WriteLine();
                     Console.Error.WriteLine($"Error opening resource file {filename}");

Analyzer/README.md

@@ -4,37 +4,20 @@ The Analyzer is a class library that can be used to analyze the content of Unity
 as AssetBundles and SerializedFiles. It iterates through all the serialized objects and uses the
 TypeTree to extract information about these objects (e.g. name, size, etc.)
 
-The extracted information is forwarded to an object implementing the [IWriter](./IWriter.cs)
-interface. The library provides the [SQLiteWriter](./SQLite/SQLiteWriter.cs) implementation that
-writes the data into a SQLite database.
+The most common use of this library is through the [analyze](../UnityDataTool/README.md#analyzeanalyse)
+command of the UnityDataTool.  This uses the Analyze library to generate a SQLite database.
 
-It is possible to extract type-specific properties using classes inheriting from the
-[SerializedObject](./SerializedObjects/SerializedObject.cs) class. The project already provides
-the most common SerializedObject implementations in the [SerializedObjects](./SerializedObjects)
-folder.
+Once generated, a tool such as the [DB Browser for SQLite](https://sqlitebrowser.org/), or the command line `sqlite3` tool, can be used to look at the content of the database.
 
-# How to use the library
+# Example usage
 
-The [AnalyzerTool](./AnalyzerTool.cs) class is the API entry point. The main method is called
-Analyze. It is currently hardcoded to write using the [SQLiteWriter](./SQLite/SQLiteWriter.cs),
-but it can easily be adapter to use another writer type. It takes four parameters:
-* path (string): path of the folder where the files to analyze are located. It will be searched
-  recursively.
-* databaseName (string): database filename, it will be overwritten if it already exists.
-* searchPattern (string): file search pattern (e.g. \*.bundle).
-* skipReferences (bool): determines if the CRC calculation and references (PPtrs) extraction must
-  skipped. This is faster, but the refs table will be empty and the duplicate assets won't be
-  accurate.
-Calling this method will create the SQLite output database and will recursively
-process the files matching the search pattern in the provided path. It will add a row in
-the 'objects' table for each serialized object. This table contain basic information such as the
-size and the name of the object (if it has one).
-
-# How to use the database
-
-A tool such as the [DB Browser for SQLite](https://sqlitebrowser.org/) is required to look at the
-content of the database. The database provides different views that can be used to easily find the
-information you might need.
+See [this topic](../Documentation/analyze-examples.md) for examples of how to use the SQLite output of the UnityDataTool Analyze command.
+
+# DataBase Reference
+
+The database provides different views.  The views join multiple tables together and often it is not necessary to write your own SQL queries to find the information you want, especially when you are using a visual SQLite tool.
+
+This section gives an overview of the main views.
 
 ## object_view
 
@@ -178,3 +161,34 @@ stripping it won't make a big difference.
 This view lists all the shaders aggregated by name. The *instances* column indicates how many time
 the shader was found in the data files. It also provides the total size per shader and the list of
 AssetBundles in which they were found.
+
+# Advanced
+
+## Using the library
+
+The [AnalyzerTool](./AnalyzerTool.cs) class is the API entry point. The main method is called
+Analyze. It is currently hard coded to write using the [SQLiteWriter](./SQLite/SQLiteWriter.cs),
+but this approach could be extended to add support for other outputs.
+
+Calling this method will recursively process the files matching the search pattern in the provided
+path. It will add a row in the 'objects' table for each serialized object. This table contain basic
+information such as the size and the name of the object (if it has one).
+
+## Extending the Library
+
+The extracted information is forwarded to an object implementing the [IWriter](./IWriter.cs)
+interface. The library provides the [SQLiteWriter](./SQLite/SQLiteWriter.cs) implementation that
+writes the data into a SQLite database.
+
+The core properties that apply to all Unity Objects are extracted into the `objects` table.
+However much of the most useful Analyze functionality comes by virtue of the type-specific information that is extracted for
+important types like Meshes, Shaders, Texture2D and AnimationClips.  For example, when a Mesh object is encountered in a Serialized
+File, then rows are added to both the `objects` table and the `meshes` table.  The meshes table contains columns that only apply to Mesh objects, for example the number of vertices, indices, bones, and channels.  The `mesh_view` is a view that joins the `objects` table with the `meshes` table, so that you can see all the properties of a Mesh object in one place.
+
+Each supported Unity object type follows the same pattern:
+* A Handler class in the SQLite/Handlers (e.g. [MeshHandler.cs](./SQLite/Handler/MeshHandler.cs).
+* The registration of the handler in the m_Handlers dictionary in [SQLiteWriter.cs](./SQLite/SQLiteWriter.cs).
+* SQL statements defining extra tables and views associated with the type, e.g. [Mesh.sql](./SQLite/Resources/Mesh.sql).
+* A Reader class that uses RandomAccessReader to read properties from the serialized object. e.g. [Mesh.cs](./SerializedObjects/Mesh.cs).
+
+It would be possible to extend the Analyze library to add additional columns for the existing types, or by following the same pattern to add additional types.  The [dump](../UnityDataTool/README.md#dump) feature of UnityDataTool is a useful way to see the property names and other details of the serialization for a type.  Based on that information, code in the Reader class can use the RandomAccessReader to retrieve those properties to bring them into the SQLite database.

Analyzer/SQLite/SQLiteWriter.cs

@@ -23,7 +23,7 @@ public class SQLiteWriter : IWriter
     private Util.ObjectIdProvider m_ObjectIdProvider = new ();
 
     private Regex m_RegexSceneFile = new(@"BuildPlayer-([^\.]+)(?:\.sharedAssets)?");
-    
+
     // Used to map PPtr fileId to its corresponding serialized file id in the database.
     Dictionary<int, int> m_LocalToDbFileId = new ();
 
@@ -37,7 +37,7 @@ public class SQLiteWriter : IWriter
         { "AssetBundle", new AssetBundleHandler() },
         { "PreloadData", new PreloadDataHandler() },
     };
-    
+
     private SqliteConnection m_Database;
     private SqliteCommand m_AddReferenceCommand = new SqliteCommand();
     private SqliteCommand m_AddAssetBundleCommand = new SqliteCommand();
@@ -82,9 +82,9 @@ public void Begin()
             // Console.WriteLine($"Connection state before init: {m_Database.State}");
             handler.Init(m_Database);
             // Console.WriteLine($"Connection state after init: {m_Database.State}");
-            
+
         }
-        
+
         CreateSQLiteCommands();
     }
 
@@ -94,7 +94,7 @@ public void End()
         {
             throw new InvalidOperationException("SQLiteWriter.End called before SQLiteWriter.Begin");
         }
-        
+
         foreach (var handler in m_Handlers.Values)
         {
             handler.Finalize(m_Database);
@@ -125,7 +125,7 @@ private void CreateSQLiteCommands()
         m_AddReferenceCommand.Parameters.Add("@referenced_object", SqliteType.Integer);
         m_AddReferenceCommand.Parameters.Add("@property_path", SqliteType.Text);
         m_AddReferenceCommand.Parameters.Add("@property_type", SqliteType.Text);
-        
+
         m_AddObjectCommand = m_Database.CreateCommand();
         m_AddObjectCommand.CommandText = "INSERT INTO objects (id, object_id, serialized_file, type, name, game_object, size, crc32) VALUES (@id, @object_id, @serialized_file, @type, @name, @game_object, @size, @crc32)";
         m_AddObjectCommand.Parameters.Add("@id", SqliteType.Integer);
@@ -154,7 +154,7 @@ public void BeginAssetBundle(string name, long size)
         {
             throw new InvalidOperationException("SQLWriter.BeginAssetBundle called twice");
         }
-        
+
         m_CurrentAssetBundleId = m_NextAssetBundleId++;
         m_AddAssetBundleCommand.Parameters["@id"].Value = m_CurrentAssetBundleId;
         m_AddAssetBundleCommand.Parameters["@name"].Value = name;
@@ -171,7 +171,7 @@ public void EndAssetBundle()
 
         m_CurrentAssetBundleId = -1;
     }
-    
+
     public void WriteSerializedFile(string relativePath, string fullPath, string containingFolder)
     {
         using var sf = UnityFileSystem.OpenSerializedFile(fullPath);
@@ -188,8 +188,8 @@ public void WriteSerializedFile(string relativePath, string fullPath, string con
         if (match.Success)
         {
             var sceneName = match.Groups[1].Value;
-            
-            // There is no Scene object in Unity (a Scene is the full content of a 
+
+            // There is no Scene object in Unity (a Scene is the full content of a
             // SerializedFile). We generate an object id using the name of the Scene
             // as SerializedFile name, and the object id 0.
             sceneId = m_ObjectIdProvider.GetId((m_SerializedFileIdProvider.GetId(sceneName), 0));
@@ -212,7 +212,7 @@ public void WriteSerializedFile(string relativePath, string fullPath, string con
                 m_AddObjectCommand.ExecuteNonQuery();
             }
         }
-        
+
         m_LocalToDbFileId.Clear();
 
         Context ctx = new()
@@ -275,7 +275,7 @@ public void WriteSerializedFile(string relativePath, string fullPath, string con
                 {
                     name = randomAccessReader["m_Name"].GetValue<string>();
                 }
-                
+
                 if (randomAccessReader.HasChild("m_GameObject"))
                 {
                     var pptr = randomAccessReader["m_GameObject"];
@@ -316,7 +316,7 @@ public void WriteSerializedFile(string relativePath, string fullPath, string con
 
             transaction.Commit();
         }
-        catch (Exception e)
+        catch (Exception)
         {
             transaction.Rollback();
             throw;