Примеры кода

var sw = Stopwatch.StartNew();
const int count = 100;

var employees = CreateEmployees(count);

// Bulk insert using COPY protocol (Pro feature)
var savedIds = await redb.SaveAsync(employees); 

sw.Stop();

// Classic ORM: ~25 tables, ~5000 INSERTs with FK ordering
// REDB: 2 tables, ~3000 values, single BulkInsert

var sw = Stopwatch.StartNew();

var employee = new RedbObject<EmployeeProps>
{
    name = "New Developer",
    Props = new EmployeeProps
    {
        FirstName = "Alice",
        LastName = "Johnson",
        Age = 28,
        Position = "Developer",
        Department = "Engineering",
        Salary = 85000m,
        HireDate = DateTime.Today,
        EmployeeCode = "EMP-NEW-001",
        Skills = ["C#", "React", "SQL"]
    }
};

var id = await redb.SaveAsync(employee);
sw.Stop();

var sw = Stopwatch.StartNew();

// Get any existing employee ID
var query = redb.Query<EmployeeProps>().Take(1);
var items = await query.ToListAsync();

if (items.Count == 0)
{
    sw.Stop();
    return Fail("E002", "LoadAsync - Load Employee by ID", ExampleTier.Free, sw.ElapsedMilliseconds,
        "No employees found. Run E000 first.");
}

var id = items[0].Id;
var loaded = await redb.LoadAsync<EmployeeProps>(id);

if (loaded != null)
{
    EmployeeProps? employee = (EmployeeProps)loaded;
}

sw.Stop();

await redb.SyncSchemeAsync<ProductProps>();

// Unique per run so the example is rerunnable on a shared database.
var sku = $"SKU-{Guid.NewGuid():N}"[..20];
var sw = Stopwatch.StartNew();

// 1. The first holder of the key wins.
var first = new RedbObject<ProductProps>
{
    name = "unique-demo-first",
    Props = new ProductProps { Sku = sku, Title = "First holder", Price = 9.99m }
};
var firstId = await redb.SaveAsync(first);

// 2. A duplicate is rejected by the database with a typed exception.
string rejected;
try
{
    await redb.SaveAsync(new RedbObject<ProductProps>
    {
        name = "unique-demo-duplicate",
        Props = new ProductProps { Sku = sku, Title = "Impostor", Price = 0.99m }
    });
    rejected = "NOT rejected - this line must never print";
}
catch (RedbUniqueViolationException ex)
{
    rejected = $"rejected with {nameof(RedbUniqueViolationException)} (property: {ex.PropertyName ?? "Sku"})";
}

// 3. Lookup by key value - one server-side hash probe, no scan.
var found = await redb.GetByUniqueAsync<ProductProps>(p => p.Sku, sku);

// 4. NULL keys do not collide: both keyless products save fine.
await redb.SaveAsync(new RedbObject<ProductProps> { name = "no-key-a", Props = new ProductProps { Title = "Draft A" } });
await redb.SaveAsync(new RedbObject<ProductProps> { name = "no-key-b", Props = new ProductProps { Title = "Draft B" } });

// 5. Soft delete releases the key for the next claimant.
await redb.DeleteAsync(firstId);
var successor = new RedbObject<ProductProps>
{
    name = "unique-demo-successor",
    Props = new ProductProps { Sku = sku, Title = "Successor", Price = 19.99m }
};
var successorId = await redb.SaveAsync(successor);

// 6. The OBJECT-level key: value_unique lives on the object row itself - no Props
//    field involved - and is unique across the whole scheme.
var objectKey = $"EXT-{Guid.NewGuid():N}"[..20];
var holder = new RedbObject<ProductProps>
{
    name = "object-key-holder",
    value_unique = objectKey,
    Props = new ProductProps { Title = "Holder of the object key" }
};
await redb.SaveAsync(holder);

string objectRejected;
try
{
    await redb.SaveAsync(new RedbObject<ProductProps>
    {
        name = "object-key-impostor",
        value_unique = objectKey,
        Props = new ProductProps { Title = "Impostor" }
    });
    objectRejected = "NOT rejected - this line must never print";
}
catch (RedbUniqueViolationException ex)
{
    // ex.Kind tells WHICH mechanism fired: ObjectKey here vs Property for [RedbUnique].
    objectRejected = $"rejected with {nameof(RedbUniqueViolationException)} (Kind: {ex.Kind})";
}

sw.Stop();

await redb.SyncSchemeAsync<DeviceProps>();

// Unique per run so the example is rerunnable on a shared database.
var run = Guid.NewGuid().ToString("N")[..8];
var sw = Stopwatch.StartNew();

// 1. Key on a scalar inside a nested class: same rules as a root key.
var serial = $"SN-{run}";
var alphaId = await redb.SaveAsync(Device("alpha", d => d.Identity = new DeviceIdentity { Serial = serial, Vendor = "Acme" }));
var nestedDup = await Rejected(() => redb.SaveAsync(Device("alpha-dup", d => d.Identity = new DeviceIdentity { Serial = serial, Vendor = "Other" })));
var bySerial = await redb.GetByUniqueAsync<DeviceProps>(d => d.Identity!.Serial, serial);

// 2. Subtree key: the CONTENT of the nested class is the key. Same content - rejected;
//    one field different - a different key. The lookup canonicalises the probe object
//    the same way the save did.
var region = $"eu-{run}";
var betaId = await redb.SaveAsync(Device("beta", d => d.Config = new DeviceConfig { Region = region, Tier = 2 }));
var subtreeDup = await Rejected(() => redb.SaveAsync(Device("beta-dup", d => d.Config = new DeviceConfig { Region = region, Tier = 2 })));
await redb.SaveAsync(Device("beta-tier3", d => d.Config = new DeviceConfig { Region = region, Tier = 3 }));
var byConfig = await redb.GetByUniqueAsync<DeviceProps>(d => d.Config, new DeviceConfig { Region = region, Tier = 2 });

// 3. Subtree key on a collection: the ordered list is the key.
var basePort = Random.Shared.Next(10_000, 60_000);
List<long> ports = [basePort, basePort + 1, basePort + 2];
await redb.SaveAsync(Device("gamma", d => d.Ports = ports));
var listDup = await Rejected(() => redb.SaveAsync(Device("gamma-dup", d => d.Ports = [.. ports])));
await redb.SaveAsync(Device("gamma-reversed", d => d.Ports = [basePort + 2, basePort + 1, basePort]));

// 4. Element keys, Collection scope: no duplicate label inside ONE device. Another device
//    may carry the same label - the scope is the collection, not the scheme.
await redb.SaveAsync(Device("delta", d => d.Labels = ["rack-1", "spare"]));
await redb.SaveAsync(Device("delta-twin", d => d.Labels = ["rack-1"]));
var elementDup = await Rejected(() => redb.SaveAsync(Device("delta-dup", d => d.Labels = ["rack-1", "rack-1"])));

// 5. Element keys, Scheme scope: a MAC address belongs to one device in the whole scheme,
//    and the holder is found by the element value.
var mac = $"02:{run[..2]}:{run[2..4]}:{run[4..6]}:00:01";
// The second address comes from the same run characters as the first: the key is unique across the
// scheme, and two characters alone (256 values) collide with earlier runs of this example.
var epsilonId = await redb.SaveAsync(Device("epsilon", d => d.MacAddresses = [mac, $"02:{run[..2]}:{run[2..4]}:{run[4..6]}:00:02"]));
var macDup = await Rejected(() => redb.SaveAsync(Device("epsilon-dup", d => d.MacAddresses = [mac])));
var byMac = await redb.GetByUniqueAsync<DeviceProps>(d => d.MacAddresses, mac);

// 6. [RedbTags]: the markers are metadata - read them back from the synced scheme.
var scheme = await redb.GetSchemeByTypeAsync<DeviceProps>();
var schemeTags = scheme?.Tags;
var macTags = scheme?.GetStructureByName(nameof(DeviceProps.MacAddresses))?.Tags;

sw.Stop();

// The example is a contract probe: a duplicate that slipped through, a lookup that missed
// or a tag that did not land is a FAIL, not a line in the report.
var problems = new List<string>();
if (!nestedDup.StartsWith("rejected")) problems.Add("nested key: duplicate was not rejected");
if (bySerial?.Id != alphaId) problems.Add("nested key: lookup by lambda path missed");
if (!subtreeDup.StartsWith("rejected")) problems.Add("subtree key: duplicate content was not rejected");
if (byConfig?.Id != betaId) problems.Add("subtree key: lookup by content missed");
if (!listDup.StartsWith("rejected")) problems.Add("collection key: duplicate list was not rejected");
if (!elementDup.StartsWith("rejected")) problems.Add("element key (Collection): duplicate inside one device was not rejected");
if (!macDup.StartsWith("rejected")) problems.Add("element key (Scheme): duplicate across devices was not rejected");
if (byMac?.Id != epsilonId) problems.Add("element key (Scheme): lookup by element value missed");
if (schemeTags != "examples,e004") problems.Add($"[RedbTags] on the scheme did not land: '{schemeTags}'");
if (macTags != "network") problems.Add($"[RedbTags] on the structure did not land: '{macTags}'");
if (problems.Count > 0)
    return Fail("E004", "Unique Keys - nested, subtree and element keys, [RedbTags]", ExampleTier.Free, sw.ElapsedMilliseconds, string.Join("; ", problems));

var sw = Stopwatch.StartNew();

var query = redb.Query<EmployeeProps>()
    .Where(e => e.Salary > 75000m)
    .Take(100);

// Uncomment to see generated SQL:
// var sql = await query.ToSqlStringAsync();
// Console.WriteLine(sql);

var result = await query.ToListAsync();
sw.Stop();

var sw = Stopwatch.StartNew();

var query = redb.Query<EmployeeProps>()
    .Where(e => e.Age >= 30 && e.Salary > 70000m)
    .Take(100);

// Uncomment to see generated SQL:
// var sql = await query.ToSqlStringAsync();
// Console.WriteLine(sql);

var result = await query.ToListAsync();
sw.Stop();

var sw = Stopwatch.StartNew();

var query = redb.Query<EmployeeProps>()
    .Where(e => e.Age < 30 || e.Salary > 90000m)
    .Take(100);

// Uncomment to see generated SQL:
// var sql = await query.ToSqlStringAsync();
// Console.WriteLine(sql);

var result = await query.ToListAsync();
sw.Stop();

var sw = Stopwatch.StartNew();

var query = redb.Query<EmployeeProps>()
    .Where(e => e.Position != "Manager")
    .Take(100);

// Uncomment to see generated SQL:
// var sql = await query.ToSqlStringAsync();
// Console.WriteLine(sql);

var result = await query.ToListAsync();
sw.Stop();

var sw = Stopwatch.StartNew();

var query = redb.Query<EmployeeProps>()
    .Where(e => e.Salary >= 60000m && e.Salary < 90000m)
    .Take(100);

// Uncomment to see generated SQL:
// var sql = await query.ToSqlStringAsync();
// Console.WriteLine(sql);

var result = await query.ToListAsync();
sw.Stop();