174 lines
4.0 KiB
Markdown
174 lines
4.0 KiB
Markdown
# Syntax Deep Dive and Procedure Calls
|
|
|
|
This guide focuses on the two query syntaxes and advanced stored procedure invocation patterns.
|
|
|
|
## Two Query Syntax Styles
|
|
|
|
DynamORM supports:
|
|
|
|
- Dynamic table syntax: concise runtime calls via `dynamic`.
|
|
- Fluent builder syntax: explicit SQL composition via interfaces and lambda parser.
|
|
|
|
## Dynamic Table Syntax
|
|
|
|
Entry point:
|
|
|
|
```csharp
|
|
dynamic users = db.Table("users");
|
|
```
|
|
|
|
Typical reads:
|
|
|
|
```csharp
|
|
var count = users.Count(columns: "id");
|
|
var first = users.First(columns: "id,first,last");
|
|
var one = users.Single(id: 19);
|
|
var list = (users.Query(columns: "id,first", order: "id:desc") as IEnumerable<dynamic>).ToList();
|
|
```
|
|
|
|
Dynamic filters with `DynamicColumn`:
|
|
|
|
```csharp
|
|
users.Count(where: new DynamicColumn("id").Greater(100));
|
|
users.Count(where: new DynamicColumn("last").In("Hendricks", "Goodwin", "Freeman"));
|
|
```
|
|
|
|
Modifications:
|
|
|
|
```csharp
|
|
users.Insert(code: "201", first: "Juri", last: "Gagarin");
|
|
users.Update(values: new { first = "Yuri" }, where: new { code = "201" });
|
|
users.Delete(code: "201");
|
|
```
|
|
|
|
Coverage references:
|
|
|
|
- `DynamORM.Tests/Select/DynamicAccessTests.cs`
|
|
- `DynamORM.Tests/Modify/DynamicModificationTests.cs`
|
|
|
|
## Fluent Builder Syntax
|
|
|
|
Entry points:
|
|
|
|
```csharp
|
|
var q1 = db.From("users", "u");
|
|
var q2 = db.From<Users>("u");
|
|
```
|
|
|
|
Composable select:
|
|
|
|
```csharp
|
|
using (var query = db.From<Users>("u")
|
|
.Where(x => x.u.id > 10)
|
|
.Select(x => x.u.id, x => x.u.first)
|
|
.OrderBy(x => x.u.id.Desc()))
|
|
{
|
|
var rows = query.Execute().ToList();
|
|
}
|
|
```
|
|
|
|
Parser forms supported by tests:
|
|
|
|
- `From(x => x.dbo.Users)`
|
|
- `From(x => x.dbo.Users.As(x.u))`
|
|
- `From(x => "dbo.Users AS u")`
|
|
- `From(x => x(subQuery).As("u"))`
|
|
- `Join(x => x.Left().Accounts.As(x.a).On(x.a.userId == x.u.id))`
|
|
|
|
Coverage references:
|
|
|
|
- `DynamORM.Tests/Select/ParserTests.cs`
|
|
- `DynamORM.Tests/Select/LegacyParserTests.cs`
|
|
|
|
## Choosing Between Syntaxes
|
|
|
|
Use dynamic table syntax when:
|
|
|
|
- You want short CRUD calls quickly.
|
|
- Table/column selection is runtime-driven.
|
|
|
|
Use fluent builder syntax when:
|
|
|
|
- You want explicit SQL structure and deterministic command text.
|
|
- You need complex joins/subqueries/parser features.
|
|
- You prefer typed projections (`Execute<T>()`, `ScalarAs<T>()`).
|
|
|
|
## Stored Procedure Deep Dive
|
|
|
|
`db.Procedures` provides dynamic invocation of stored procedures.
|
|
|
|
## Basic Calls
|
|
|
|
```csharp
|
|
var r0 = db.Procedures.sp_Exp_Scalar();
|
|
var r1 = db.Procedures.sp_Exp_Scalar<int>();
|
|
```
|
|
|
|
## Namespaced Procedure Names
|
|
|
|
`TryGetMember` composes member segments before invocation:
|
|
|
|
```csharp
|
|
var r = db.Procedures.dbo.reporting.sp_MonthlySales();
|
|
```
|
|
|
|
Final procedure name becomes `dbo.reporting.sp_MonthlySales`.
|
|
|
|
## Direction Prefixes
|
|
|
|
Argument name prefixes drive parameter direction:
|
|
|
|
- `out_` => `ParameterDirection.Output`
|
|
- `ret_` => `ParameterDirection.ReturnValue`
|
|
- `both_` => `ParameterDirection.InputOutput`
|
|
|
|
Example:
|
|
|
|
```csharp
|
|
dynamic res = db.Procedures.sp_Test_Scalar_In_Out(
|
|
inp: Guid.NewGuid(),
|
|
out_outp: Guid.Empty,
|
|
ret_Return: 0);
|
|
```
|
|
|
|
Returned object exposes values without prefixes.
|
|
|
|
## Advanced Parameter Shape
|
|
|
|
You can pass:
|
|
|
|
- plain values
|
|
- `DynamicColumn` with schema and direction metadata
|
|
- `DynamicSchemaColumn`
|
|
- `DynamicExpando` / `ExpandoObject`
|
|
|
|
Example with explicit output schema:
|
|
|
|
```csharp
|
|
var res = db.Procedures.sp_Exp_SomeInputAndOutput<string, MyProcResult>(
|
|
Name: "G4g4r1n",
|
|
out_Result: new DynamicSchemaColumn { Name = "Result", Size = 256 },
|
|
ret_Return: 0);
|
|
```
|
|
|
|
## Generic Result Shapes
|
|
|
|
From `DynamicProcedureInvoker` behavior:
|
|
|
|
- `T == IDataReader`: returns cached reader (`CachedReader()`).
|
|
- `T == DataTable`: materializes via `ToDataTable()`.
|
|
- `T == IEnumerable<object>`: dynamic row enumeration.
|
|
- `T == IEnumerable<primitive>`: scalar conversion per row.
|
|
- `T == IEnumerable<class>`: mapping with mapper cache.
|
|
- `T == class`: mapped single/object payload.
|
|
|
|
## Return and Output Aggregation
|
|
|
|
When output/return params are present, DynamORM aggregates:
|
|
|
|
- main result
|
|
- each output parameter
|
|
- return value
|
|
|
|
into a dynamic object or mapped result type (if a mapping type is provided).
|