cslightdbgen.sqlitegen 2026.416.1848

CSharpLightDbGen

A Roslyn incremental source generator that emits strongly-typed SQLite data-access code at compile time for attributed C# models. Zero runtime reflection, zero runtime dependencies from the generator itself — just fast, predictable ADO.NET calls.

Why?

Quick Start

1. Install

Add the source generator to your project:

<ItemGroup>
  <ProjectReference Include="path/to/cslightdbgen.sqlitegen.csproj"
                    OutputItemType="Analyzer"
                    ReferenceOutputAssembly="false" />
</ItemGroup>

Add a runtime SQLite provider (e.g., Microsoft.Data.Sqlite).

2. Define a Model

using CsLightDbGen.SQLiteGenerator;

[LdgSQLiteTable("customers")]
public partial class Customer
{
    [LdgSQLiteKey]
    public int CustomerId { get; set; }

    public string Name { get; set; } = string.Empty;

    public int Age { get; set; }

    public int SegmentKey { get; set; }

    public int? Score { get; set; }
}

The class must be partial. The generator will produce a companion partial with all data-access methods.

3. Use the Generated API

using var db = new SqliteConnection("Data Source=:memory:");
db.Open();

// Create the table
Customer.CreateTable(db);

// Insert
var customer = new Customer { Name = "Alice", Age = 30, SegmentKey = 1 };
Customer.Insert(db, customer);

// Query
Customer? found = Customer.SelectSingle(db, Name: "Alice");
List<Customer> young = Customer.SelectList(db, AgeOperator: "<=", Age: 25);

// Extension methods work too
customer.Update(db);
customer.Delete(db);

Attributes

Generated API Surface

Standard Table ([LdgSQLiteTable])

Schema: CreateTable, DropTable

Reads: SelectSingle, SelectList, SelectEnumerable, SelectDict, SelectCount

• Filter by any property via named parameters
• Numeric operator filters (Age, AgeOperator: ">=")
• Nullable tri-state filters (ScoreIsNull: true)
• IN-list filters for *Key properties (SegmentKeyValues: [1, 2, 3])
• LIKE matching for strings (compareStringsWithLike: true)
• Paging (resultLimit, resultOffset) and ordering (orderByProperties, orderByDirection)
• Unknown orderByProperties values are ignored; generated models expose SQLiteColumnNames for the valid SQLite column names

Writes: Insert, Update, Delete — single value, list, or enumerable overloads

• ignoreDuplicates → INSERT OR IGNORE
• insertPrimaryKey → include PK in insert

Utilities: LoadMaxKey, SelectMaxKey, SQLiteColumnNames

Extensions: convenience methods on IDbConnection, model instances, and collections

FTS Table ([LdgSQLiteFtsTable])

CreateTable, DropTable, Populate, Select (via MATCH), SelectCount

• Optional HTML stripping during Populate(..., sanitizeText: true)
• Generated FTS models also expose SQLiteColumnNames, and invalid orderByProperties values are ignored

Full-Text Search Example

[LdgSQLiteFtsTable("article_source")]
public partial class ArticleSearch
{
    public string Title { get; set; } = string.Empty;
    public string Body { get; set; } = string.Empty;

    [LdgSQLiteFtsUnindexed]
    public string? RawHtml { get; set; }
}

// Populate FTS index from source table
ArticleSearch.Populate(db);

// Search
var results = ArticleSearch.Select(db, ["sqlite", "performance"]);
int count = ArticleSearch.SelectCount(db, ["sqlite"]);

Record Class Support

Both class and record class models are supported:

[LdgSQLiteTable("orders")]
public partial record class Order
{
    [LdgSQLiteKey]
    public int OrderId { get; set; }
    public int CustomerKey { get; set; }
    public string Description { get; set; } = string.Empty;
}

Performance

Benchmarked against Dapper and EF Core on .NET 10 (BenchmarkDotNet v0.15.6, i9-13900KF):

Single Record Select

Multi-Record Filtered Select

Multi-Record Unfiltered Select

Single Insert

Bulk Insert (1,000 rows)

Key takeaways:

• Reads: 1.2–1.4× faster than Dapper, 2–8× faster than EF Core
• Writes: Competitive with Dapper, 5–7× faster than EF Core
• Memory: Consistently lowest allocations across all benchmarks

Project Structure

src/
  cslightdbgen.sqlitegen/             # Roslyn incremental source generator
tests/
  cslightdbgen.sqlitegen.tests/       # Unit tests (generator contract verification)
  cslightdbgen.sqlitegen.integration/ # Integration tests (runtime SQLite behavior)
  cslightdbgen.performance/           # BenchmarkDotNet comparisons
docs/                                 # Developer documentation

Building & Testing

# Build
dotnet build db-gen.slnx -c Release

# Unit tests
dotnet test tests/cslightdbgen.sqlitegen.tests -c Release

# Integration tests
dotnet test tests/cslightdbgen.sqlitegen.integration -c Release

# Benchmarks
dotnet run -c Release --project tests/cslightdbgen.performance

Documentation

Detailed developer docs are in the docs/ directory:

• Onboarding Guide
• Architecture Overview
• Process Flows
• Generated API Contract
• Commands and Options
• Dependencies

Technical Details

• Generator targets netstandard2.0 for maximum IDE/SDK compatibility
• Uses Roslyn Microsoft.CodeAnalysis.CSharp 4.14.0
• Generated code uses only ADO.NET abstractions (IDbConnection, IDbCommand, IDataReader)
• No runtime reflection for CRUD operations
• Parameterized SQL for all values
• C# 14.0 language features

License

MIT — Copyright (c) Gino Canessa