redb.Export 1.2.14

REDB — Entity Database for .NET

SQL speed. NoSQL flexibility. Pure C# schemas. Zero migrations.

REDB is an EAV-based database engine for .NET that stores typed objects as JSON properties in a relational backend (PostgreSQL, MSSQL). You define schemas as plain C# classes — REDB handles storage, indexing, querying, trees, lists, aggregation, and window functions through a single LINQ-style API.

Quick Start

// 1. Define a schema — that's your migration
[RedbScheme("Employee")]
public class EmployeeProps
{
    public string FirstName { get; set; } = "";
    public string LastName { get; set; } = "";
    public int Age { get; set; }
    public decimal Salary { get; set; }
    public string Department { get; set; } = "";
    public string[] Skills { get; set; } = [];
    public Address? HomeAddress { get; set; }
    public Dictionary<int, decimal>? BonusByYear { get; set; }
}

// 2. Sync scheme (creates storage automatically)
await redb.SyncSchemeAsync<EmployeeProps>();

// 3. Save
var emp = new RedbObject<EmployeeProps> {
    name = "John Smith",
    Props = new EmployeeProps { FirstName = "John", Salary = 95000, Skills = ["C#", "SQL"] }
};
await redb.SaveAsync(emp);

// 4. Query with full LINQ
var seniors = await redb.Query<EmployeeProps>()
    .Where(e => e.Salary > 80000 && e.Skills.Contains("C#"))
    .OrderByDescending(e => e.Salary)
    .ToListAsync();

Packages

Package	NuGet	Description
redb.Core		Core abstractions, query builder, LINQ provider
redb.Postgres		PostgreSQL provider (free, MIT)
redb.MSSql		Microsoft SQL Server provider (free, MIT)
redb.Core.Pro		Pro extensions: parallel materialization, change tracking, migrations
redb.Postgres.Pro		PostgreSQL Pro provider with optimized query generation
redb.MSSql.Pro		MSSQL Pro provider with optimized query generation
redb.Export		CSV/JSON/XML/YAML/Markdown export with templates

Installation

# PostgreSQL
dotnet add package redb.Core
dotnet add package redb.Postgres

# or MSSQL
dotnet add package redb.Core
dotnet add package redb.MSSql

# Pro (optional)
dotnet add package redb.Core.Pro
dotnet add package redb.Postgres.Pro   # or redb.MSSql.Pro

Setup & InitializeAsync

using redb.Core;
using redb.Postgres; // or redb.MSSql

var builder = WebApplication.CreateBuilder(args);

// Register REDB
builder.Services.AddRedb(options =>
{
    options.ConnectionString = "Host=localhost;Database=mydb;Username=postgres;Password=pass";
});

var app = builder.Build();

// Initialize with automatic schema creation
var redb = app.Services.GetRequiredService<IRedbService>();
await redb.InitializeAsync(ensureCreated: true);

Database Setup Options

REDB provides several ways to create the database schema:

Option A — Automatic on startup (recommended):

// Creates schema if missing, then initializes
await redb.InitializeAsync(ensureCreated: true);

Option B — Explicit call:

await redb.EnsureDatabaseAsync(); // idempotent — safe to call every time
await redb.InitializeAsync();

Option C — Export SQL script for DBA / CI:

var sql = redb.GetSchemaScript();
File.WriteAllText("redb_schema.sql", sql);

Option D — CLI tool:

dotnet tool install --global redb.CLI

# Create schema in an existing database
redb init --connection "Host=localhost;Database=mydb;..." --provider postgres

# Export SQL to file
redb schema --provider postgres --output redb_schema.sql

Capabilities

CRUD

Object Graph (RedbObject References in Props)

Props can contain RedbObject<T> properties — single, array, or dictionary. The entire graph is saved and loaded in one call. No JOINs, no Include chains, no manual assembly.

[RedbScheme]
public class OrderProps
{
    public string Title { get; set; } = "";

    // Single nested object with its own Props
    public RedbObject<PaymentProps>? Payment { get; set; }

    // Array of nested objects
    public RedbObject<MetricsProps>[]? RelatedMetrics { get; set; }

    // Dictionary of nested objects
    public Dictionary<string, RedbObject<CouponProps>>? Coupons { get; set; }
}

// Save — entire graph persisted, ParentId set automatically
await redb.SaveAsync(order);

// Load — full graph reconstructed, all nested objects hydrated
var loaded = await redb.LoadAsync<OrderProps>(id);
// loaded.Props.Payment.Props          — ready
// loaded.Props.RelatedMetrics[0].Props — ready
// loaded.Props.Coupons["SUMMER"].Props — ready

Nested objects are real RedbObject instances with their own id, name, DateCreate, DateModify, and Props. They can be queried independently, updated in place, and participate in tree structures.

Rich Props Structure

Props fields can be any combination of scalars, nested classes, collections, and dictionaries — arbitrarily deep. Everything is serialized, stored, and fully restored on load. No extra tables, no FKs, no mapping.

[RedbScheme("Analytics Record")]
public class AnalyticsRecordProps
{
    // Scalars
    public string Title { get; set; } = "";
    public int Views { get; set; }
    public decimal Revenue { get; set; }

    // Primitive arrays
    public string[]? Tags { get; set; }
    public int[]? Scores { get; set; }

    // Nested business class
    public Address? HomeAddress { get; set; }

    // Array of business classes
    public Contact[]? Contacts { get; set; }

    // Dictionary<string, primitive>
    public Dictionary<string, string>? PhoneBook { get; set; }

    // Dictionary<int, decimal>
    public Dictionary<int, decimal>? PriceList { get; set; }

    // Dictionary<string, nested class>
    public Dictionary<string, Address>? AddressBook { get; set; }

    // Dictionary<string, complex class with its own arrays and dicts>
    public Dictionary<string, ProjectInfo>? ComplexBook { get; set; }

    // Tuple key dictionary
    public Dictionary<(int, string), string>? TupleKeyDict { get; set; }
}

public class Address
{
    public string City { get; set; } = "";
    public string Street { get; set; } = "";
    public BuildingDetails? Details { get; set; }   // nesting goes deeper
}

public class ProjectInfo
{
    public string Title { get; set; } = "";
    public int Priority { get; set; }
    public string[]? Tags { get; set; }             // arrays inside dict values
    public MetricTag[]? MetricTags { get; set; }    // class arrays inside dict values
    public Dictionary<string, int>? Scores { get; set; } // dict inside dict value
}

All saved and loaded with a single SaveAsync / LoadAsync. Fields can be added or removed at any time — SyncSchemeAsync handles it.

Where Filters

DateTime

String Operations

Nested Properties

Array Operations

Dictionary Operations

Projection & Pagination

Existence & Count

Arithmetic & Math

Aggregation

GroupBy

Window Functions

Tree Structures

Built-in hierarchical data with closure-table storage and recursive CTEs.

Lists (Reference Dictionaries)

Named lookup lists with items, useful for statuses, categories, roles.

Export

Users, Roles & Permissions

Built-in user management with password hashing, roles, and object-level permissions. No external identity provider required.

// Authenticate
var user = await redb.UserProvider.ValidateUserAsync("admin", "password123");
if (user != null)
{
    redb.SetCurrentUser(user);
    // All subsequent operations run as this user
}

// Temporary system elevation (skip permissions)
using (redb.CreateSystemContext())
{
    await redb.SaveAsync(sensitiveObject);
}

Architecture

IRedbService          ← single entry point
├── Query<T>()        ← flat LINQ queries
├── TreeQuery<T>()    ← hierarchical queries
├── SaveAsync()       ← create / update
├── LoadAsync<T>()    ← load by ID
├── ListProvider      ← reference dictionaries
├── UserProvider      ← users, authentication, passwords
├── RoleProvider      ← roles and user-role assignments
├── SecurityContext   ← current user, permission checks
└── SyncSchemeAsync() ← auto-migration from C# class

Storage is provider-based. Each [RedbScheme] class maps to an EAV structure in the target database. Schema changes (new fields, removed fields, type changes) are handled automatically by SyncSchemeAsync — no migration files needed.

Supported backends: PostgreSQL, Microsoft SQL Server.

Pro

REDB Pro unlocks faster query execution, parallel materialization, deep nested property queries, arithmetic and math expressions in WHERE, Sql.Function<T>() for calling arbitrary SQL functions, change tracking, schema migrations, and advanced analytics (window functions over grouped data). If performance matters — use Pro.

redbase.app/pricing

License

Core packages (redb.Core, redb.Postgres, redb.MSSql) are MIT-licensed. Pro packages require a commercial license — see LICENSE-PRO.txt.