# Fluent Builder API

The fluent API is built around interfaces like:

- `IDynamicSelectQueryBuilder`
- `IDynamicInsertQueryBuilder`
- `IDynamicUpdateQueryBuilder`
- `IDynamicDeleteQueryBuilder`

This API is best when SQL structure must be explicit and composable.

## Core Select Flow

```csharp
using (var query = db.From("users", "u")
    .Where("u.id", 19)
    .SelectColumn("u.first", "u.last"))
{
    var result = query.Execute().ToList();
}
```

## Typed Select

```csharp
using (var query = db.From<User>("u")
    .Where(x => x.u.id == 19)
    .Select(x => x.u.All()))
{
    var users = query.Execute<User>().ToList();
}
```

## Parser Lambda Patterns

The parser supports patterns tested in `DynamORM.Tests/Select/ParserTests.cs` and `DynamORM.Tests/Select/LegacyParserTests.cs`:

- `From(x => x.dbo.Users)`
- `From(x => x.dbo.Users.As(x.u))`
- `From(x => "dbo.Users AS u")`
- `Join(x => x.Left().Accounts.As(x.a).On(x.a.userId == x.u.id))`
- `Where(x => x.Or(x.u.id > 100))`
- `Select(x => x.u.first.As(x.firstName))`
- `GroupBy(x => x.u.last)`
- `Having(x => x.Count() > 1)`
- `OrderBy(x => x.u.id.Desc())`

## Joins and Projection Example

```csharp
using (var query = db.From("users", "u")
    .Join(x => x.Left().profiles.As(x.p).On(x.p.user_id == x.u.id))
    .Select(
        x => x.u.id,
        x => x.u.first.As(x.firstName),
        x => x.p.city.As(x.city))
    .Where(x => x.u.id > 10)
    .OrderBy(x => x.u.id.Desc()))
{
    var rows = query.Execute().ToList();
}
```

## Subqueries

```csharp
var sub = new DynamicSelectQueryBuilder(db)
    .From(x => x.dbo.Users)
    .Where(x => x.id > 100);

using (var query = new DynamicSelectQueryBuilder(db)
    .From(x => x(sub).As("u"))
    .Select(x => x.u.All()))
{
    var rows = query.Execute().ToList();
}
```

## Scalar Helpers

```csharp
var count = db.From<User>()
    .Select(x => x.Count())
    .ScalarAs<int>();
```

## Modify Builders

```csharp
db.Insert("users")
    .Values("code", "301")
    .Values("first", "Ada")
    .Execute();

db.Update("users")
    .Values("first", "Alicia")
    .Where("id", 301)
    .Execute();

db.Delete("users")
    .Where("id", 301)
    .Execute();
```

Typed variant:

```csharp
db.Insert<User>()
    .Values(x => x.code, "302")
    .Values(x => x.first, "Grace")
    .Execute();
```

## SQL Inspection

You can inspect generated SQL from builder objects:

```csharp
var sql = query.CommandText();
```

Command text assertions are heavily used in parser tests.