Code Examples

var sw = Stopwatch.StartNew();

// Create a temporary object to delete
var scheme = await redb.EnsureSchemeFromTypeAsync<EmployeeProps>();
var tempObj = new RedbObject<EmployeeProps>
{
    name = $"ToDelete_{DateTime.UtcNow.Ticks}",
    scheme_id = scheme.Id,
    Props = new EmployeeProps
    {
        FirstName = "Temporary",
        LastName = "Employee",
        Age = 25,
        Salary = 50000m,
        Department = "Test"
    }
};

var id = await redb.SaveAsync(tempObj);

// Verify it exists
var beforeDelete = await redb.LoadAsync<EmployeeProps>(id);
var existsBefore = beforeDelete != null;

// Delete the object
await redb.DeleteAsync(id);

// Verify it's deleted
var afterDelete = await redb.LoadAsync<EmployeeProps>(id);
var existsAfter = afterDelete != null;

sw.Stop();

if (!existsBefore || existsAfter)
{
    return Fail("E181", "Delete - Single Object", ExampleTier.Free, sw.ElapsedMilliseconds,
        $"Delete verification failed. Before: {existsBefore}, After: {existsAfter}");
}

var sw = Stopwatch.StartNew();

// Create temporary objects to delete
var scheme = await redb.EnsureSchemeFromTypeAsync<EmployeeProps>();
var batchId = DateTime.UtcNow.Ticks;
var tempObjects = new List<RedbObject<EmployeeProps>>();

for (int i = 0; i < 5; i++)
{
    tempObjects.Add(new RedbObject<EmployeeProps>
    {
        name = $"BatchDelete_{batchId}_{i}",
        scheme_id = scheme.Id,
        Props = new EmployeeProps
        {
            FirstName = $"Temp{i}",
            LastName = "Employee",
            Age = 20 + i,
            Salary = 40000m + i * 1000,
            Department = "Test"
        }
    });
}

// Save all
var ids = await redb.SaveAsync(tempObjects.Cast<Core.Models.Contracts.IRedbObject>());

// Verify count before delete
var countBefore = (await redb.LoadAsync(ids)).Count;

// Delete all by IDs
foreach (var id in ids)
{
    await redb.DeleteAsync(id);
}

// Verify count after delete
var countAfter = (await redb.LoadAsync(ids)).Count;

sw.Stop();

var sw = Stopwatch.StartNew();

// Get first employee with salary > 80000
var highEarner = await redb.Query<EmployeeProps>()
    .Where(e => e.Salary > 80000m)
    .OrderByDescending(e => e.Salary)
    .FirstOrDefaultAsync();

// Get first with impossible condition (should be null)
var notFound = await redb.Query<EmployeeProps>()
    .Where(e => e.Salary > 10_000_000m)
    .FirstOrDefaultAsync();

sw.Stop();

if (highEarner == null)
{
    return Fail("E183", "FirstOrDefaultAsync", ExampleTier.Free, sw.ElapsedMilliseconds,
        "No employees with salary > 80000 found.");
}

var sw = Stopwatch.StartNew();

// Find employees where EmployeeCode is null
var withoutCode = await redb.Query<EmployeeProps>()
    .Where(e => e.EmployeeCode == null)
    .Take(5)
    .ToListAsync();

var nullCount = await redb.Query<EmployeeProps>()
    .Where(e => e.EmployeeCode == null)
    .CountAsync();

// Find employees where EmployeeCode is NOT null
var withCode = await redb.Query<EmployeeProps>()
    .Where(e => e.EmployeeCode != null)
    .Take(5)
    .ToListAsync();

var notNullCount = await redb.Query<EmployeeProps>()
    .Where(e => e.EmployeeCode != null)
    .CountAsync();

sw.Stop();

var sampleCode = withCode.FirstOrDefault()?.Props.EmployeeCode ?? "N/A";

var sw = Stopwatch.StartNew();

// Combined conditions: Age > 30 AND Salary > 70000
var expHighEarnersCount = await redb.Query<EmployeeProps>()
    .Where(e => e.Age > 30 && e.Salary > 70000m)
    .CountAsync();

var expHighEarners = await redb.Query<EmployeeProps>()
    .Where(e => e.Age > 30 && e.Salary > 70000m)
    .Take(5)
    .ToListAsync();

// OR conditions: Department == "IT" OR Department == "Engineering"
var techDeptCount = await redb.Query<EmployeeProps>()
    .Where(e => e.Department == "IT" || e.Department == "Engineering")
    .CountAsync();

sw.Stop();

var names = expHighEarners.Take(3).Select(e => $"{e.Props.FirstName} ({e.Props.Age}, ${e.Props.Salary:N0})");

var sw = Stopwatch.StartNew();

// Ensure schemes exist
var projectScheme = await redb.EnsureSchemeFromTypeAsync<ProjectMetricsProps>();
var employeeScheme = await redb.EnsureSchemeFromTypeAsync<EmployeeProps>();

// Create a project
var project = new RedbObject<ProjectMetricsProps>
{
    name = $"RefProject_{DateTime.UtcNow.Ticks}",
    scheme_id = projectScheme.Id,
    Props = new ProjectMetricsProps
    {
        ProjectId = 1001,
        TasksCompleted = 50,
        TasksTotal = 100,
        Budget = 500000
    }
};

var id1 = await redb.SaveAsync(project);
//Console.WriteLine($"First object id: {id1}");

// Create employee with project reference
var employee = new RedbObject<EmployeeProps>
{
    name = $"RefEmployee_{DateTime.UtcNow.Ticks}",
    scheme_id = employeeScheme.Id,
    Props = new EmployeeProps
    {
        FirstName = "John",
        LastName = "ProjectManager",
        Age = 35,
        Salary = 90000m,
        Department = "Engineering",
        CurrentProject = project // Reference to another RedbObject
    }
};

var id2 = await redb.SaveAsync(employee);
//Console.WriteLine($"Second object id: {id2}");

// Load employee and access referenced project
var loaded = await redb.LoadAsync<EmployeeProps>(employee.Id);

sw.Stop();

if (loaded?.Props?.CurrentProject == null)
{
    // Cleanup
    await redb.DeleteAsync(employee.Id);
    await redb.DeleteAsync(project.Id);
    
    return Fail("E186", "Object Reference - Load", ExampleTier.Free, sw.ElapsedMilliseconds,
        "CurrentProject reference not loaded.");
}

var projName = loaded.Props.CurrentProject.name;
var projBudget = loaded.Props.CurrentProject.Props?.Budget ?? 0;

// Cleanup
await redb.DeleteAsync(employee.Id);
await redb.DeleteAsync(project.Id);

var sw = Stopwatch.StartNew();

// Create an object to update
var scheme = await redb.EnsureSchemeFromTypeAsync<EmployeeProps>();
var original = new RedbObject<EmployeeProps>
{
    name = $"ToUpdate_{DateTime.UtcNow.Ticks}",
    scheme_id = scheme.Id,
    Props = new EmployeeProps
    {
        FirstName = "Original",
        LastName = "Name",
        Age = 30,
        Salary = 60000m,
        Department = "Sales"
    }
};
await redb.SaveAsync(original);
var originalSalary = original.Props.Salary;

// Load the object
var loaded = await redb.LoadAsync<EmployeeProps>(original.Id);
if (loaded == null)
{
    sw.Stop();
    return Fail("E187", "Update - Existing Object", ExampleTier.Free, sw.ElapsedMilliseconds,
        "Failed to load object for update.");
}

// Modify Props
loaded.Props.FirstName = "Updated";
loaded.Props.Salary = 75000m; // Raise!
loaded.Props.Department = "Engineering";

// Save changes (same ID = update)
await redb.SaveAsync(loaded);

// Verify changes
var verified = await redb.LoadAsync<EmployeeProps>(original.Id);

sw.Stop();

// Cleanup
await redb.DeleteAsync(original.Id);

if (verified == null)
{
    return Fail("E187", "Update - Existing Object", ExampleTier.Free, sw.ElapsedMilliseconds,
        "Failed to verify updated object.");
}

var sw = Stopwatch.StartNew();

// Uncomment to see generated SQL:
//var sql = await redb.Query<EmployeeProps>()
//    .Where(x => x.Department == "Engineering")
//    .ToSqlStringAsync();
//Console.WriteLine(sql);

// Sum salaries only for Engineering department
var engineeringSalary = await redb.Query<EmployeeProps>()
    .Where(x => x.Department == "Engineering")
    .SumAsync(x => x.Salary);

// Compare with total (no filter)
var totalSalary = await redb.Query<EmployeeProps>()
    .SumAsync(x => x.Salary);

sw.Stop();

var sw = Stopwatch.StartNew();

// Window with filter: only high earners (Salary > 70000)
var windowQuery = redb.Query<EmployeeProps>()
    .Where(x => x.Salary > 70000m)
    .Take(20)
    .WithWindow(w => w
        .PartitionBy(x => x.Department)
        .OrderByDesc(x => x.Salary));

// Uncomment to see generated SQL:
//var sql = await windowQuery.ToSqlStringAsync(x => new { x.Props.FirstName, Rank = Win.RowNumber() });
//Console.WriteLine(sql);

var ranked = await windowQuery.SelectAsync(x => new
{
    Name = x.Props.FirstName,
    Department = x.Props.Department,
    Salary = x.Props.Salary,
    Rank = Win.RowNumber()
});

sw.Stop();

var top = ranked.FirstOrDefault();

var sw = Stopwatch.StartNew();

// Aggregate only Developers
var query = redb.Query<EmployeeProps>()
    .Where(x => x.Position == "Developer");

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

var stats = await query.AggregateAsync(x => new
{
    TotalSalary = Agg.Sum(x.Props.Salary),
    AvgSalary = Agg.Average(x.Props.Salary),
    MinSalary = Agg.Min(x.Props.Salary),
    MaxSalary = Agg.Max(x.Props.Salary),
    Count = Agg.Count()
});

sw.Stop();