Sobre o projeto
# RedBase — armazenamento de objetos tipados para .NET
RedBase é uma plataforma de dados para .NET que armazena objetos tipados em um backend relacional (PostgreSQL, Microsoft SQL Server ou SQLite — incluindo embarcado/offline, Blazor WebAssembly e mobile via o provedor SQLite). Você define esquemas como classes C# simples — RedBase cuida do armazenamento, indexação, consulta, árvores, listas, agregação e funções de janela através de uma única API no estilo LINQ.
Sem Entity Framework. Sem migrações. Sem cadeias de Include com 40 tabelas. Apenas classes C# e uma linha para salvar, uma linha para carregar.
## Por que RedBase
- **Esquema = classe C#**: Adicione um campo adicionando uma propriedade à sua classe; `SyncSchemeAsync()` cuida do resto. Sem arquivos de migração.
- **Grafo de objeto completo**: Referências aninhadas `RedbObject<T>` (única, array, dicionário) são salvas e carregadas em uma única chamada — sem JOINs ou cadeias de Include.
- **Tipagem forte**: Cada propriedade mapeia para uma coluna tipada dedicada com restrições de FK e índices — não blobs JSON. Consultável no nível SQL.
- **Árvores integradas**: `TreeQuery<T>()` com CTEs recursivas, profundidade, ancestrais e caminho até a raiz.
- **API de consulta rica**: Suporte completo a LINQ incluindo filtros Where, projeções, GroupBy, agregações e funções de janela (ROW_NUMBER, RANK, LAG/LEAD, NTILE, frames personalizados).
- **Múltiplos provedores**: PostgreSQL, MSSQL e SQLite (incluindo C# puro para Blazor WebAssembly e mobile).
## Início Rápido
```csharp
// 1. Defina um esquema — essa é sua "migração"
[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 Position { get; set; } = "";
public DateTime HireDate { get; set; }
public string[]? Skills { get; set; }
public Address? HomeAddress { get; set; }
public Dictionary<int, decimal>? BonusByYear { get; set; }
}
// 2. Sincronize o esquema (cria o armazenamento automaticamente)
await redb.SyncSchemeAsync<EmployeeProps>();
// 3. Salve
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,
Skills = ["C#", "React", "SQL"]
}
};
await redb.SaveAsync(employee);
// 4. Carregue
var loaded = await redb.LoadAsync<EmployeeProps>(employee.Id);
// 5. Consulte
var results = await redb.Query<EmployeeProps>()
.Where(e => e.Salary > 75000m)
.OrderByDescending(e => e.Salary)
.Take(100)
.ToListAsync();
```
## Pacotes
| Pacote | Descrição |
|---------|-------------|
| `redb.Core` | Abstrações principais, construtor de consultas, provedor LINQ |
| `redb.Postgres` | Provedor PostgreSQL (gratuito, Apache 2.0) |
| `redb.MSSql` | Provedor Microsoft SQL Server (gratuito, Apache 2.0) |
| `redb.SQLite` | Provedor SQLite (gratuito, Apache 2.0) — embarcado/offline, extensão nativa carregável |
| `redb.Core.Pro` | Extensões Pro: materialização paralela, rastreamento de alterações, migrações |
| `redb.Postgres.Pro` | Provedor PostgreSQL Pro com geração de consultas otimizada |
| `redb.MSSql.Pro` | Provedor MSSQL Pro com geração de consultas otimizada |
| `redb.SQLite.Pro` | Provedor SQLite Pro — C# puro (sem extensão nativa): Blazor WebAssembly e mobile |
| `redb.Export` | Exportação/importação de banco de dados: arquivos `.redb` (JSONL/ZIP) para backup, migração entre PostgreSQL ↔ MSSQL |
## Capacidades
### CRUD
- Salvar objetos únicos ou em lote
- Carregar por ID com grafo de objeto completo
- Inserção em massa via protocolo COPY
- Excluir com purga opcional
### Estrutura Rica de Props
Props podem conter escalares, classes aninhadas, arrays, dicionários (incluindo chaves de tupla) e referências `RedbObject` — arbitrariamente profundos. Todos salvos e carregados com uma única chamada.
### Recursos de Consulta
- **Filtros Where**: comparações, AND/OR/NOT, `WhereIn`, verificações de nulos, filtros de campos base
- **Operações de string**: Contains, StartsWith, insensível a maiúsculas/minúsculas (com suporte a collation ICU para texto não-inglês)
- **Propriedades aninhadas**: filtrar em campos de classes aninhadas em qualquer profundidade
- **Operações de array**: Contains elemento, combinações any/all
- **Operações de dicionário**: ContainsKey, filtros de indexador, valores aninhados
- **Projeção e paginação**: Select, Distinct, OrderBy/ThenBy, Skip/Take, FirstOrDefault
- **Agregação**: Sum, Average, Min/Max, agregação em lote, agregação filtrada
- **GroupBy**: chaves únicas ou compostas, agrupamento por elemento de array
- **Funções de janela**: ROW_NUMBER, RANK, DENSE_RANK, somas acumuladas, LAG/LEAD, FIRST/LAST_VALUE, NTILE, frames personalizados
### Estruturas de Árvore
Dados hierárquicos integrados com armazenamento em closure-table e CTEs recursivas:
- Criar nós filhos
- Carregar árvore completa com limite de profundidade
- Obter filhos/descendentes
- Caminho até a raiz
## Instalação
```bash
# PostgreSQL (Gratuito)
dotnet add package redb.Postgres
# ou MSSQL (Gratuito)
dotnet add package redb.MSSql
# Pro — inclui redb.Core.Pro automaticamente
dotnet add package redb.Postgres.Pro # ou redb.MSSql.Pro
```
## Configuração
```csharp
using redb.Core;
using redb.Core.Extensions;
using redb.Postgres.Pro.Extensions;
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddRedbPro(options => options
.UsePostgres("Host=localhost;Database=mydb;Username=postgres;Password=pass")
.Configure(c =>
{
c.PropsSaveStrategy = PropsSaveStrategy.ChangeTracking;
c.EnableLazyReferences = false;
c.EnablePropsCache = true;
}));
var app = builder.Build();
var redb = app.Services.GetRequiredService<IRedbService>();
await redb.InitializeAsync();
await redb.SyncSchemeAsync<EmployeeProps>();
```
A versão gratuita usa `AddRedb` em vez de `AddRedbPro`.
## Opções de Configuração do Banco de Dados
- Automática na inicialização (`InitializeAsync(ensureCreated: true)`)
- Chamada explícita (`EnsureDatabaseAsync()` + `InitializeAsync()`)
- Exportar script SQL para DBA/CI (`GetSchemaScript()`)
- Ferramenta CLI (`redb init`, `redb schema`)
## Lado do cliente: Blazor WebAssembly e mobile
Ambos rodam em `redb.SQLite.Pro` (C# puro). Mobile não precisa de nada especial; Blazor WebAssembly requer relink nativo, inicialização manual e persistência no nível da aplicação.
## Licença
Apache 2.0 para pacotes gratuitos; pacotes Pro requerem uma licença (não necessária nas linhas 3.x/4.x para SQLite.Pro).
Comments
0 people shared their preference · Deer Point appears after 10 participants
Sign in to join the discussion.