RestySqlite/DatabaseWrapper.cs

using Microsoft.Data.Sqlite;

namespace RestySqlite
{

    public struct Parameter
    {
        public string Name;
        public dynamic Value;

        public Parameter(string name, dynamic value)
        {
            Name = name;
            Value = value;
        }
    }

    public class DatabaseWrapper
    {
        public SqliteConnection Connection {get; set;}
        public string DatabaseName {get; set; }

        public DatabaseWrapper(string databaseName)
        {
            string connectionString = $"Data Source={databaseName}.db;";
            DatabaseName = databaseName;

            Connection = new(connectionString);
            Console.WriteLine($"Connected to {DatabaseName}");

        }

        public void ExecuteCommand(string sqlCommand, params Parameter[] parameters)
        {
            Connection.Open();
            SqliteCommand comm = new(sqlCommand, Connection);
            
            if (parameters.Length != 0)
            {
                foreach (Parameter param in parameters)
                {
                    comm.Parameters.AddWithValue(param.Name, param.Value);
                }
            }

            comm.ExecuteNonQuery();
        }

        public SqliteDataReader? GetReader(string sqlCommand, params Parameter[] parameters)
        {
            Connection.Open();
            SqliteCommand comm = new(sqlCommand, Connection);

            if (parameters.Length != 0)
            {
                foreach (Parameter param in parameters)
                {
                    comm.Parameters.AddWithValue(param.Name, param.Value);
                }
            }

            var reader = comm.ExecuteReader();
            return reader;
        }

        public List<string> MapTables()
        {
            var reader = this.GetReader(@"
                SELECT *
                FROM sqlite_master
                WHERE type='table'
            ");

            List<string> tables = new();
            using (reader)
            {
                while (reader.Read())
                {
                    var table = reader.GetString(1);
                    tables.Add(table);
                }
            }

            return tables;
        }

        public Dictionary<string, List<string>> MapColumns()
        {
            Dictionary<string, List<string>> columnMap = new();
            var tables = this.MapTables();
            foreach (string table in tables)
            {
                var reader = this.GetReader($"pragma table_info({table});");

                using (reader)
                {
                    while (reader.Read())
                    {
                        var col = reader.GetString(1);
                        if (columnMap.ContainsKey(table))
                        {
                            columnMap[table].Add(col);
                            continue;
                        }
                        columnMap.Add(table,new List<string>{col});
                    }
                }
            }

            foreach (var table in columnMap)
            {
                Console.WriteLine($"{table.Key}\n--------");

                foreach (var column in table.Value)
                {
                    var reader = this.GetReader($"SELECT {column} FROM {table.Key}");
                    Console.WriteLine(column);
                    try
                    {
                        while (reader.Read())
                        {
                            Console.WriteLine(reader.GetString(0));
                        }
                        Console.WriteLine("---------");
                    }
                    catch (Exception e)
                    {
                        Console.WriteLine($"Something broken: {e.Message}");
                    }
                    
                }
            }
            return columnMap;
        }

        ~DatabaseWrapper()
        {
            Connection.Close();
            Console.WriteLine($"Disconected from {DatabaseName}");
        }
    }
}