SoloTable.Firebird 0.1.0-preview.3

SoloTable

Single-table schema sync and additive scaffold for .NET 8 / .NET 9.

What this is: create or alter one table at a time (code-first), and scaffold C# / EF models without wiping other tables or other generated files (additive DB-first).

What this is not: a full ORM, EF migrations replacement, or a tool that rewrites your entire database model on every run.

Install one provider package, connect with its facade, then either:

Current release: 0.1.0-preview — evaluation / early adoption. APIs may change before 1.0.

Author: Pankaj Jadhav · GitHub · License: MIT

Positioning (read this first)

Install

Pick only the database you use:

dotnet add package SoloTable.Sqlite
dotnet add package SoloTable.MySql        # MySQL + MariaDB
dotnet add package SoloTable.PostgreSql
dotnet add package SoloTable.SqlServer
dotnet add package SoloTable.Oracle
dotnet add package SoloTable.Firebird

Preview packages require a matching version (or --prerelease):

dotnet add package SoloTable.MySql --version 0.1.0-preview.3

Connection strings

SQLite:      Data Source=app.db
MySQL:       Server=localhost;Port=3306;Database=mydb;Uid=root;Pwd=secret;
PostgreSQL:  Host=localhost;Port=5432;Database=mydb;Username=postgres;Password=secret
SQL Server:  Server=localhost;Database=mydb;Trusted_Connection=True;TrustServerCertificate=True
Oracle:      User Id=scott;Password=tiger;Data Source=localhost:1521/XEPDB1
Firebird:    Database=app.fdb;User=SYSDBA;Password=masterkey;DataSource=localhost

Code-first (C# → database) — one table

Create or alter one table from a CLR type or a fluent definition.

using System.ComponentModel.DataAnnotations;
using System.ComponentModel.DataAnnotations.Schema;
using SoloTable;
using SoloTable.MySql; // or Sqlite / PostgreSql / SqlServer / ...

[Table("Orders")]
public class Order
{
    [Key]
    public long Id { get; set; }

    [Required, MaxLength(100)]
    public string CustomerName { get; set; } = "";
}

var db = MySqlFacade.Connect(
    "Server=localhost;Port=3306;Database=mydb;Uid=root;Pwd=secret;");

// From entity type — only table "Orders"
await db.CodeFirst().Entity<Order>().SyncAsync();

// One-shot helper
await db.CodeFirst().EnsureAsync<Order>();

// Fluent definition (no entity class required)
await db.CodeFirst()
    .Table("Orders")
    .Define(t => t
        .Column("Id", ColumnDbType.Int64, c => c.PrimaryKey(identity: true))
        .Column("CustomerName", ColumnDbType.String, c => c.NotNull().MaxLength(100))
        .Column("Notes", ColumnDbType.String, c => c.Nullable()))
    .SyncAsync();

// Dry-run: generate SQL without executing
var sql = await db.CodeFirst().Entity<Order>().GenerateScriptAsync();

Adding a property on Order and calling SyncAsync() again only alters that table (additive by default).

DB-first (database → C#) — additive scaffold

Single table (POCO)

Inspect or scaffold a partial POCO from one existing table. Writing one file never deletes others.

var db = MySqlFacade.Connect(connectionString);

var live = await db.DbFirst().Table("Orders").InspectAsync();

var scaffold = await db.DbFirst()
    .Table("Orders")
    .Scaffold()
    .WithNamespace("MyApp.Models")
    .WithDataAnnotations()
    .GenerateAsync();

Console.WriteLine(scaffold.SourceCode);

await db.DbFirst()
    .Table("Orders")
    .GenerateToFileAsync("Orders.cs");

db.Scaffold("Orders") is a shorthand for db.DbFirst().Table("Orders").Scaffold().

EF Core model (partial entities + DbContext + Fluent API)

Generated code targets EF Core. Add Microsoft.EntityFrameworkCore and your EF database provider in the consuming app.

Multi-table — entities + DbContext / OnModelCreating (still additive on disk: only listed tables’ files are written/updated):

await db.DbFirst()
    .Tables("Customers", "Orders")   // or .Schema() for all tables
    .ScaffoldEf()
    .WithNamespace("MyApp.Data")
    .WithContextName("AppDbContext")
    .WithDataAnnotations()
    .GenerateToDirectoryAsync("./Generated");

Single-table EF scaffold is additive — updates only that entity file, and if context generation is enabled, merges that table’s DbSet / Fluent config into the existing DbContext (other entities stay):

await db.DbFirst()
    .Table("Orders")
    .ScaffoldEf()
    .WithContext()          // merge into existing AppDbContext.cs
    .WithNamespace("MyApp.Data")
    .GenerateToDirectoryAsync("./Generated");

GenerateToDirectoryAsync never deletes sibling entity files, and never replaces an existing DbContext wholesale when only a subset of tables is scaffolded.

Consumers still need EF packages, for example:

dotnet add package Microsoft.EntityFrameworkCore
dotnet add package Pomelo.EntityFrameworkCore.MySql   # or Npgsql / SqlServer / ...

Round-trip

await db.CodeFirst().EnsureAsync<Order>();
await db.DbFirst().Table("Orders").GenerateToFileAsync("Generated/Order.cs");

Safety defaults

SoloTable code-first targets only the named table:

• Never emits DROP TABLE
• Never mutates other tables
• DROP COLUMN and other destructive changes are skipped unless you opt in:

await db.CodeFirst()
    .Entity<Order>()
    .WithOptions(o => o.AllowDestructive = true)
    .SyncAsync();

Dry-run / script generation never executes DDL:

.WithOptions(o => o.DryRun = true)
// or
.GenerateScriptAsync()

More detail: Safety policy on GitHub

Target frameworks

• net8.0
• net9.0

Design notes

• Single-table / additive scaffold by design — not a full-schema migration product
• Facade pattern — engines and dialects stay internal
• Release builds — assemblies are obfuscated; symbol packages are not published
• Install one provider per app

Docs: NuGet setup · Providers · Testing · Protection · Publish