Requêtes de base et pagination

var context = BaseDal.Db;

// Requête SQL brute
var result = await context.Ado.SqlQueryAsync<projet>("SELECT * FROM Projets WHERE Statut = @Statut", new { Statut = "Actif" });

// Requête LINQ Lambda
var projetAvecPlanning = await context.Queryable<projet planning="">((pr, pl) => pr.Id == pl.ProjetId && pr.Id == 456789)
    .Select((pr, pl) => pr)
    .FirstAsync();

var projetSimple = await context.Queryable<projet>()
    .Where(p => p.Id == 456789)
    .FirstAsync();

// Requête avec condition dynamique
var projetFiltre = await context.Queryable<projet>()
    .Where(p => p.Id == 987654)
    .WhereIF(5 > 10, p => p.Id > 50)
    .FirstAsync();

// Pagination
var totalCount = new RefAsync<int>();
var projetsPage = await context.Queryable<projet>()
    .ToPageListAsync(1, 10, totalCount);

// Requête multi-tables avec pagination
var totalJointure = new RefAsync<int>();
var projetsAvecDetails = await context.Queryable<projet planning="">((pr, pl) =>
        new JoinQueryInfos(JoinType.Left, pr.Id == pl.ProjetId && pr.CodeEntreprise == "TechCorp"))
    .ToPageListAsync(2, 20, totalJointure);
</projet></int></projet></int></projet></projet></projet></projet>

Insertion et mise à jour d'entités

// Insertion d'une entité avec retour de l'identifiant
var nouveauProjet = new Projet();
int idInsere = await context.Insertable(nouveauProjet).ExecuteReturnIdentityAsync();

// Mise à jour en ignorant certains champs (nécessite une clé)
await context.Updateable(nouveauProjet)
    .IgnoreColumns(p => new { p.CreePar, p.DateCreation })
    .ExecuteCommandAsync();

Transactions synchrones

public void OperationSynchrone()
{
    try
    {
        DbScoped.SugarScope.BeginTran();
        // Logique métier ici
        DbScoped.SugarScope.CommitTran();
    }
    catch (Exception)
    {
        DbScoped.SugarScope.RollbackTran();
        throw;
    }
}

Transactions asynchrones

public async Task<apiresult> ExecuterTransactionAsync()
{
    var resultat = await DbScoped.Sugar.UseTranAsync(async () =>
    {
        var liste = await DbScoped.Sugar.Queryable<entitetest>()
            .Where(e => e.Id > 0)
            .ToListAsync();
        
        var element = liste[0];
        element.Prix = 750;
        element.Actif = false;
        element.Nom = "NouveauNom";
        element.Id = 0;
        
        await DbScoped.Sugar.Insertable(element).ExecuteCommandAsync();
        // Possibilité de lancer une exception pour annuler
    });

    return resultat.IsSuccess
        ? ApiResult.ToSuccess(resultat.ErrorException)
        : ApiResult.ToFailure(resultat.ErrorException);
}
</entitetest></apiresult>

Requêtes multi-tables avec tri et pagination

var paginationTotal = new RefAsync<int>();
var donnees = await DbScoped.Sugar.Queryable<inspection detailsutilisateur="" institution="">(
        (ins, usr, inst) => new JoinQueryInfos(
            JoinType.Left, ins.UtilisateurId == usr.Id,
            JoinType.Left, ins.InstitutionId == inst.Id))
    .WhereIF(filtre.InstitutionId > 0, (ins, usr, inst) => ins.InstitutionId == filtre.InstitutionId)
    .WhereIF(dateFin > dateDebut, (ins, usr, inst) => ins.Date >= dateDebut && ins.Date <= dateFin)
    .Select((ins, usr, inst) => new InspectionDto
    {
        Id = ins.Id,
        // Autres champs
    })
    .OrderByDescending(c => c.Date)
    .ToPageListAsync(filtre.Page, filtre.TaillePage, paginationTotal);

int totalEnregistrements = paginationTotal.Value;
int pagesTotales = (int)Math.Ceiling((double)totalEnregistrements / filtre.TaillePage);
</inspection></int>

Exemple de mise à jour avec SqlSugar

// Mise à jour basée sur la clé primaire
var entiteMaj = new EntiteTest();
int lignes = db.Updateable(entiteMaj).ExecuteCommand();

// Suivi des modifications pour une mise à jour partielle
db.Tracking(entiteMaj);
entiteMaj.Nom = "ValeurModifiee";
db.Updateable(entiteMaj).ExecuteCommand(); // Seul le champ modifié est mis à jour

// Mise à jour en masse pour de grands jeux de données
db.Fastest<entitelourde>().BulkUpdate(obtenirListe());
</entitelourde>

Mise à jour partielel ou spécifique de champs

// Ignorer certaines colonnes lors de la mise à jour
var resultatIgnore = db.Updateable(entiteMaj)
    .IgnoreColumns(e => new { e.DateCreation, e.Id })
    .ExecuteCommand();

// Mettre à jour uniquement des colonnes spécifiques
var resultatCible = db.Updateable(entiteMaj)
    .UpdateColumns(e => new { e.Nom, e.DateModification })
    .ExecuteCommand();