Add ISqlBackupable interface and implementations for MSSQL and SQLite. Bump version to 1.9.18

Author: vkuttyp

Directory.Build.props

@@ -7,6 +7,6 @@
     <Authors>vkuttyp</Authors>
     <PackageLicenseExpression>MIT</PackageLicenseExpression>
     <RepositoryUrl>https://github.com/vkuttyp/CosmoSQLClient-Dotnet</RepositoryUrl>
-    <Version>1.9.17</Version>
+    <Version>1.9.18</Version>
   </PropertyGroup>
 </Project>

src/CosmoSQLClient.Core/BackupOptions.cs

@@ -0,0 +1,9 @@
+namespace CosmoSQLClient.Core;
+
+public record BackupOptions
+{
+    public required string DestinationPath { get; init; }
+    public bool Compression { get; init; } = true;
+    public bool Format { get; init; } = true;
+    public string? Password { get; init; }
+}

src/CosmoSQLClient.Core/ISqlBackupable.cs

@@ -0,0 +1,10 @@
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace CosmoSQLClient.Core;
+
+public interface ISqlBackupable
+{
+    Task BackupDatabaseAsync(string databaseName, BackupOptions options, CancellationToken ct = default);
+    Task RestoreDatabaseAsync(string databaseName, string sourcePath, CancellationToken ct = default);
+}

src/CosmoSQLClient.MsSql/MsSqlConnection.cs

@@ -121,7 +121,7 @@ public sealed record SqlServerInfoMessage
     public byte   State            { get; init; }
 }
 
-public sealed class MsSqlConnection : DbConnection, ISqlDatabase
+public sealed class MsSqlConnection : DbConnection, ISqlDatabase, ISqlBackupable
 {
     private readonly MsSqlConfiguration _config;
     private readonly ILogger _logger;
@@ -695,6 +695,21 @@ private static void WritePlpBytes(BinaryWriter bw, byte[]? b) {
             bw.Write((uint)0); // Terminator
         }
     }
+
+    public async Task BackupDatabaseAsync(string databaseName, BackupOptions options, CancellationToken ct = default)
+    {
+        var compression = options.Compression ? ", COMPRESSION" : "";
+        var format = options.Format ? ", FORMAT" : "";
+        var sql = $"BACKUP DATABASE [{databaseName}] TO DISK = '{options.DestinationPath}' WITH {format}{compression};";
+        
+        await ExecuteAsync(sql, null, ct).ConfigureAwait(false);
+    }
+
+    public async Task RestoreDatabaseAsync(string databaseName, string sourcePath, CancellationToken ct = default)
+    {
+        var sql = $"RESTORE DATABASE [{databaseName}] FROM DISK = '{sourcePath}' WITH REPLACE;";
+        await ExecuteAsync(sql, null, ct).ConfigureAwait(false);
+    }
 }
 
 internal static class MsSqlConnectionPoolManager

src/CosmoSQLClient.MySql/MySqlConnection.cs

@@ -54,7 +54,7 @@ public static MySqlConfiguration Parse(string connectionString)
     }
 }
 
-public sealed class MySqlConnection : DbConnection, ISqlDatabase
+public sealed class MySqlConnection : DbConnection, ISqlDatabase, ISqlBackupable
 {
     private readonly MySqlConfiguration _config;
     private readonly SemaphoreSlim _lock = new(1, 1);
@@ -351,4 +351,16 @@ public Task<SqlDataTable> QueryTableAsync(string sql, IReadOnlyList<SqlParameter
     protected override DbTransaction BeginDbTransaction(IsolationLevel isolationLevel) => throw new NotSupportedException();
     public override void ChangeDatabase(string databaseName) => throw new NotSupportedException();
     protected override DbCommand CreateDbCommand() => throw new NotSupportedException();
+
+    public Task BackupDatabaseAsync(string databaseName, BackupOptions options, CancellationToken ct = default)
+    {
+        // MySql typically requires external CLI tools (mysqldump/pg_dump).
+        // Some cloud providers support SQL-based backups, but standard installations do not.
+        throw new NotSupportedException("MySql does not support native backups via SQL commands. Use external CLI tools.");
+    }
+
+    public Task RestoreDatabaseAsync(string databaseName, string sourcePath, CancellationToken ct = default)
+    {
+        throw new NotSupportedException("MySql does not support native restore via SQL commands.");
+    }
 }

src/CosmoSQLClient.Postgres/PostgresConnection.cs

@@ -47,7 +47,7 @@ public static PostgresConfiguration Parse(string connectionString)
     }
 }
 
-public sealed class PostgresConnection : DbConnection, ISqlDatabase
+public sealed class PostgresConnection : DbConnection, ISqlDatabase, ISqlBackupable
 {
     private readonly PostgresConfiguration _config;
     private readonly SemaphoreSlim _lock = new(1, 1);
@@ -345,4 +345,16 @@ public Task<SqlDataTable> QueryTableAsync(string sql, IReadOnlyList<SqlParameter
     protected override DbTransaction BeginDbTransaction(IsolationLevel isolationLevel) => throw new NotSupportedException();
     public override void ChangeDatabase(string databaseName) => throw new NotSupportedException();
     protected override DbCommand CreateDbCommand() => throw new NotSupportedException();
+
+    public Task BackupDatabaseAsync(string databaseName, BackupOptions options, CancellationToken ct = default)
+    {
+        // Postgres typically requires external CLI tools (mysqldump/pg_dump).
+        // Some cloud providers support SQL-based backups, but standard installations do not.
+        throw new NotSupportedException("Postgres does not support native backups via SQL commands. Use external CLI tools.");
+    }
+
+    public Task RestoreDatabaseAsync(string databaseName, string sourcePath, CancellationToken ct = default)
+    {
+        throw new NotSupportedException("Postgres does not support native restore via SQL commands.");
+    }
 }

src/CosmoSQLClient.Sqlite/SqliteConnection.cs

@@ -59,7 +59,7 @@ public static SqliteConfiguration Parse(string connectionString)
 /// SQLite connection for CosmoSQLClient. Wraps <see cref="Microsoft.Data.Sqlite.SqliteConnection"/>
 /// and inherits from <see cref="DbConnection"/> for compatibility with ADO.NET.
 /// </summary>
-public sealed class SqliteConnection : DbConnection, ISqlDatabase
+public sealed class SqliteConnection : DbConnection, ISqlDatabase, ISqlBackupable
 {
     private SqliteConfiguration _config;
     private readonly Microsoft.Data.Sqlite.SqliteConnection _conn;
@@ -426,4 +426,18 @@ private static SqlValue TryParseString(string s)
             return new SqlValue.Date(dt);
         return new SqlValue.Text(s);
     }
+
+    public async Task BackupDatabaseAsync(string databaseName, BackupOptions options, CancellationToken ct = default)
+    {
+        // SQLite uses VACUUM INTO for a safe, consistent online backup
+        var sql = $"VACUUM INTO '{options.DestinationPath}';";
+        await ExecuteAsync(sql, null, ct).ConfigureAwait(false);
+    }
+
+    public Task RestoreDatabaseAsync(string databaseName, string sourcePath, CancellationToken ct = default)
+    {
+        // For SQLite, restore is usually just a file copy, but since we are a driver, 
+        // we can't easily overwrite the file we are currently connected to.
+        throw new NotSupportedException("SQLite restore via SQL command is not supported. Use file copy while the connection is closed.");
+    }
 }