Add CSV scripted importer that imports a SQLiteAsset

Author: gilzoide

Editor/Csv.meta

@@ -0,0 +1,98 @@
+/*
+ * Copyright (c) 2025 Gil Barbosa Reis
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+using System.IO;
+using SQLite.Csv;
+#if UNITY_2020_2_OR_NEWER
+using UnityEditor.AssetImporters;
+#else
+using UnityEditor.Experimental.AssetImporters;
+#endif
+using UnityEngine;
+
+namespace SQLite.Editor.Csv
+{
+    [ScriptedImporter(0, null, new[] { "csv" })]
+    public class SQLiteAssetCsvImporter : ScriptedImporter
+    {
+        [Header("SQLite asset options")]
+        [Tooltip("Name of the table that will be created for holding the CSV data inside the database.")]
+        [SerializeField] private string _tableName = "data";
+
+        [Tooltip("Flags controlling how the SQLite connection should be opened. 'ReadWrite' and 'Create' flags will be ignored, since SQLite assets are read-only.")]
+        [SerializeField] private SQLiteOpenFlags _openFlags = SQLiteOpenFlags.ReadOnly;
+
+        [Tooltip("Whether to store DateTime properties as ticks (true) or strings (false).")]
+        [SerializeField] private bool _storeDateTimeAsTicks = true;
+
+        [Tooltip("Name of the file created for the database inside Streaming Assets folder during builds.\n\n"
+            + "If empty, the database bytes will be stored in the asset itself.\n\n"
+            + "Loading databases from Streaming Assets is not supported in Android and WebGL platforms.")]
+        [SerializeField] private string _streamingAssetsPath;
+
+
+        [Header("CSV options")]
+        [Tooltip("Which separator character will be used when parsing the CSV file.")]
+        [SerializeField] private CsvReader.SeparatorChar _CSVSeparator = CsvReader.SeparatorChar.Comma;
+
+        [Tooltip("If true, the original CSV file will also be imported as a TextAsset")]
+        [SerializeField] private bool _importCSVTextAsset = false;
+
+        [Header("Additional SQL")]
+        [Tooltip("SQL script that will be run before reading CSV data. Use this for configuring the generated database using PRAGMAs like 'page_size'.")]
+        [SerializeField, Multiline] private string _SQLBeforeReadingCSV = "";
+
+        [Tooltip("SQL script that will be run after reading CSV data. Use this for changing the table's schema, creating indices, etc.")]
+        [SerializeField, Multiline] private string _SQLAfterReadingCSV = "";
+
+        public override void OnImportAsset(AssetImportContext ctx)
+        {
+            SQLiteAsset asset;
+            using (var tempDb = new SQLiteConnection(""))
+            using (var file = File.OpenRead(assetPath))
+            using (var stream = new StreamReader(file))
+            {
+                if (!string.IsNullOrWhiteSpace(_SQLBeforeReadingCSV))
+                {
+                    tempDb.Execute(_SQLBeforeReadingCSV);
+                }
+                tempDb.ImportCsvToTable(_tableName, stream, _CSVSeparator);
+                if (!string.IsNullOrWhiteSpace(_SQLAfterReadingCSV))
+                {
+                    tempDb.Execute(_SQLAfterReadingCSV);
+                }
+
+                asset = tempDb.SerializeToAsset(null, _openFlags, _storeDateTimeAsTicks, _streamingAssetsPath);
+            }
+            ctx.AddObjectToAsset("sqlite", asset);
+            ctx.SetMainObject(asset);
+
+            if (_importCSVTextAsset)
+            {
+                var textAsset = new TextAsset(File.ReadAllText(assetPath))
+                {
+                    name = $"{Path.GetFileNameWithoutExtension(assetPath)}",
+                };
+                ctx.AddObjectToAsset("text", textAsset);
+            }
+        }
+    }
+}

Editor/Csv/SQLiteAssetCsvImporter.cs

@@ -9,24 +9,21 @@ This package provides the excelent [SQLite-net](https://github.com/praeclarum/sq
   + Both synchronous and asynchronous APIs are available
   + `SQLiteConnection.Serialize` extension method for serializing a database to `byte[]` (reference: [SQLite Serialization](https://www.sqlite.org/c3ref/serialize.html)).
   + `SQLiteConnection.Deserialize` extension method for deserializing memory (`byte[]`, `NativeArray<byte>` or `ReadOnlySpan<byte>`) into an open database (reference: [SQLite Deserialization](https://www.sqlite.org/c3ref/deserialize.html)).
+  + `SQLiteConnection.ImportCsvToTable` extension method for importing a CSV text stream as a new table inside the database.
 - [SQLite3 Multiple Ciphers 2.1.3](https://github.com/utelle/SQLite3MultipleCiphers/releases/tag/v2.1.3) (based on [SQLite 3.50.1](https://sqlite.org/releaselog/3_50_1.html))
   + Supports encrypted databases
   + Enabled modules: [R\*Tree](https://sqlite.org/rtree.html), [Geopoly](https://sqlite.org/geopoly.html), [FTS5](https://sqlite.org/fts5.html), [Built-In Math Functions](https://www.sqlite.org/lang_mathfunc.html)
   + Supports Windows, Linux, macOS, WebGL, Android, iOS, tvOS and visionOS platforms
   + Supports persisting data in WebGL builds by using a [custom VFS backed by Indexed DB](https://github.com/gilzoide/idbvfs).
 - [SQLiteAsset](Runtime/SQLiteAsset.cs): read-only SQLite database Unity assets.
   + Files with the extensions ".sqlite", ".sqlite2" and ".sqlite3" will be imported as SQLite database assets.
+  + ".csv" files can be imported as SQLite database assets by changing the importer to `SQLite.Editor.Csv.SQLiteAssetCsvImporter` in the Inspector.
   + Use the `CreateConnection()` method for connecting to the database provided by the asset.
     Make sure to `Dispose()` of any connections you create.
   + SQLite assets may be loaded from Streaming Assets folder or from memory, depending on the value of their "Streaming Assets Path" property.
   + **Warning**: Android and WebGL platforms don't support loading SQLite databases from Streaming Assets and will always load them in memory.
   + `SQLiteConnection.SerializeToAsset` extension method for serializing a database to an instance of `SQLiteAsset`.
 
-## Optional packages
-- [SQLite Asset](https://github.com/gilzoide/unity-sqlite-asset): read-only SQLite database assets for Unity with scripted importer for ".sqlite", ".sqlite2" and ".sqlite3" files
-- [SQLite Asset - CSV](https://github.com/gilzoide/unity-sqlite-asset-csv): easily import ".csv" files as read-only SQLite database assets
-
-
 ## How to install
 Either:
 - Use the [openupm registry](https://openupm.com/) and install this package using the [openupm-cli](https://github.com/openupm/openupm-cli):

Editor/Csv/SQLiteAssetCsvImporter.cs.meta

@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) 2025 Gil Barbosa Reis
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+using System;
+
+namespace SQLite.Csv
+{
+    public class CsvException : Exception
+    {
+        public CsvException(string message) : base(message) {}
+    }
+}

README.md

@@ -0,0 +1,183 @@
+/*
+ * Copyright (c) 2025 Gil Barbosa Reis
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Text;
+
+namespace SQLite.Csv
+{
+    public static class CsvReader
+    {
+        public enum SeparatorChar
+        {
+            Comma,
+            Semicolon,
+            Tabs,
+        }
+
+        /// <summary>
+        /// Parse a stream of CSV-formatted data.
+        /// </summary>
+        /// <param name="stream">Stream of CSV-formatted data.</param>
+        /// <param name="separator">Character used for separating fields.</param>
+        /// <param name="maxFieldSize">Maximum field size allowed.</param>
+        /// <returns>
+        /// The enumeration returns each field's contents, even if it is empty.
+        /// <see langword="null"/> is returned at the end of the lines, meaning a new row will start next.
+        /// Empty lines are ignored and will not be enumerated.
+        /// </returns>
+        /// <exception cref="ArgumentNullException">Thrown if <paramref name="stream"/> is null.</exception>
+        /// <exception cref="CsvException">Thrown if any field size is greater than <paramref name="maxFieldSize"/>.</exception>
+        public static IEnumerable<string> ParseStream(TextReader stream, SeparatorChar separator = SeparatorChar.Comma, int maxFieldSize = int.MaxValue)
+        {
+            if (stream == null)
+            {
+                throw new ArgumentNullException(nameof(stream));
+            }
+
+            SkipEmptyLines(stream);
+            if (stream.Peek() < 0)
+            {
+                yield break;
+            }
+
+            bool insideQuotes = false;
+            var stringBuilder = new StringBuilder();
+            while (true)
+            {
+                int c = stream.Read();
+                switch (c)
+                {
+                    case '\r':
+                        if (!insideQuotes && stream.Peek() == '\n')
+                        {
+                            stream.Read();
+                            goto case '\n';
+                        }
+                        else
+                        {
+                            goto default;
+                        }
+
+                    case '\n':
+                        if (!insideQuotes)
+                        {
+                            yield return stringBuilder.ToString();
+                            stringBuilder.Clear();
+                            yield return null;
+
+                            SkipEmptyLines(stream);
+                            if (stream.Peek() < 0)
+                            {
+                                yield break;
+                            }
+                        }
+                        else
+                        {
+                            goto default;
+                        }
+                        break;
+
+                    case ',':
+                        if (!insideQuotes && separator == SeparatorChar.Comma)
+                        {
+                            yield return stringBuilder.ToString();
+                            stringBuilder.Clear();
+                        }
+                        else
+                        {
+                            goto default;
+                        }
+                        break;
+
+                    case ';':
+                        if (!insideQuotes && separator == SeparatorChar.Semicolon)
+                        {
+                            yield return stringBuilder.ToString();
+                            stringBuilder.Clear();
+                        }
+                        else
+                        {
+                            goto default;
+                        }
+                        break;
+
+                    case '\t':
+                        if (!insideQuotes && separator == SeparatorChar.Tabs)
+                        {
+                            yield return stringBuilder.ToString();
+                            stringBuilder.Clear();
+                        }
+                        else
+                        {
+                            goto default;
+                        }
+                        break;
+
+                    case '"':
+                        if (insideQuotes && stream.Peek() == '"')
+                        {
+                            stream.Read();
+                            goto default;
+                        }
+                        else
+                        {
+                            insideQuotes = !insideQuotes;
+                        }
+                        break;
+
+                    case < 0:
+                        yield return stringBuilder.ToString();
+                        yield return null;
+                        yield break;
+
+                    default:
+                        if (stringBuilder.Length >= maxFieldSize)
+                        {
+                            throw new CsvException("Field size is greater than maximum allowed size.");
+                        }
+                        stringBuilder.Append((char) c);
+                        break;
+                }
+            }
+        }
+
+        private static void SkipEmptyLines(TextReader streamReader)
+        {
+            while (true)
+            {
+                int c = streamReader.Peek();
+                switch (c)
+                {
+                    case '\n':
+                    case '\r':
+                        streamReader.Read();
+                        continue;
+
+                    default:
+                        return;
+                }
+            }
+        }
+    }
+}