Skip to content

Commit 76c1498

Browse files
coenttbcoenttb
committed
feat: complete lifted aggregate support for sum, avg, min, max
Added Select+Avg.swift, Select+Min.swift, and Select+Max.swift to complete full lifted support (Table, Where, Select) for all core SQL aggregates. Changes: - Created Select+Avg.swift (returns Double? for all numeric types) - Created Select+Min.swift (returns Value._Optionalized.Wrapped?) - Created Select+Max.swift (returns Value._Optionalized.Wrapped?) - Updated _COVERAGE.md with accurate status (all core aggregates now ✅) - Documented PostgreSQL Chapter 9 coverage and intentionally skipped features Benefits: Enables high-value ergonomic APIs: Order.avg(of: \.price, filter: { $0.status == "completed" }) Order.where { $0.year == 2024 }.max(of: \.total) Product.select().min { $0.price } Coverage Summary: - ✅ Core SQL aggregates: count, sum, avg, min, max (all complete) - ✅ ~95% of commonly-used PostgreSQL Chapter 9 functions implemented - ❌ Intentionally skipped: Bit strings, PostgreSQL ENUMs, geometric, XML (documented rationale: niche use cases, better Swift alternatives exist) All 860 tests passing.
1 parent 971d11f commit 76c1498

File tree

4 files changed

+333
-4
lines changed

4 files changed

+333
-4
lines changed

‎Sources/StructuredQueriesPostgres/Functions/Aggregate/Avg/Select+Avg.swift‎

Lines changed: 93 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,93 @@
1+
import StructuredQueriesCore
2+
3+
extension Select {
4+
/// Creates a new select statement from this one by appending an average aggregate to its selection.
5+
///
6+
/// ```swift
7+
/// Order.select().avg { $0.amount }
8+
/// // SELECT AVG("orders"."amount") FROM "orders"
9+
/// ```
10+
///
11+
/// - Parameter expression: A closure that takes table columns and returns an expression to average.
12+
/// - Returns: A new select statement that includes the average of the expression.
13+
public func avg<Value>(
14+
of expression: (From.TableColumns) -> some QueryExpression<Value>
15+
) -> Select<Double?, From, ()>
16+
where
17+
Columns == (), Joins == (),
18+
Value: _OptionalPromotable,
19+
Value._Optionalized.Wrapped: Numeric,
20+
Value._Optionalized.Wrapped: QueryRepresentable
21+
{
22+
let expr = expression(From.columns)
23+
return select { _ in expr.avg() }
24+
}
25+
26+
/// Creates a new select statement from this one by appending an average aggregate to its selection (with joins).
27+
///
28+
/// - Parameter expression: A closure that takes table columns and returns an expression to average.
29+
/// - Returns: A new select statement that includes the average of the expression.
30+
public func avg<Value, each J: Table>(
31+
of expression: (From.TableColumns, repeat (each J).TableColumns) -> some QueryExpression<Value>
32+
) -> Select<Double?, From, (repeat each J)>
33+
where
34+
Columns == (), Joins == (repeat each J),
35+
Value: _OptionalPromotable,
36+
Value._Optionalized.Wrapped: Numeric,
37+
Value._Optionalized.Wrapped: QueryRepresentable
38+
{
39+
let expr = expression(From.columns, repeat (each J).columns)
40+
return select { _ in expr.avg() }
41+
}
42+
43+
/// Creates a new select statement from this one by appending an average aggregate to its selection (with existing columns).
44+
///
45+
/// - Parameter expression: A closure that takes table columns and returns an expression to average.
46+
/// - Returns: A new select statement that includes the average of the expression.
47+
public func avg<Value, each C: QueryRepresentable, each J: Table>(
48+
of expression: (From.TableColumns, repeat (each J).TableColumns) -> some QueryExpression<Value>
49+
) -> Select<(repeat each C, Double?), From, (repeat each J)>
50+
where
51+
Columns == (repeat each C), Joins == (repeat each J),
52+
Value: _OptionalPromotable,
53+
Value._Optionalized.Wrapped: Numeric,
54+
Value._Optionalized.Wrapped: QueryRepresentable
55+
{
56+
let expr = expression(From.columns, repeat (each J).columns)
57+
return select { _ in expr.avg() }
58+
}
59+
60+
/// Creates a new select statement from this one by appending an average aggregate to its selection (with single join).
61+
///
62+
/// - Parameter expression: A closure that takes table columns and returns an expression to average.
63+
/// - Returns: A new select statement that includes the average of the expression.
64+
public func avg<Value>(
65+
of expression: (From.TableColumns, Joins.TableColumns) -> some QueryExpression<Value>
66+
) -> Select<Double?, From, Joins>
67+
where
68+
Columns == (), Joins: Table,
69+
Value: _OptionalPromotable,
70+
Value._Optionalized.Wrapped: Numeric,
71+
Value._Optionalized.Wrapped: QueryRepresentable
72+
{
73+
let expr = expression(From.columns, Joins.columns)
74+
return select { _, _ in expr.avg() }
75+
}
76+
77+
/// Creates a new select statement from this one by appending an average aggregate to its selection (with single join and existing columns).
78+
///
79+
/// - Parameter expression: A closure that takes table columns and returns an expression to average.
80+
/// - Returns: A new select statement that includes the average of the expression.
81+
public func avg<Value, each C: QueryRepresentable>(
82+
of expression: (From.TableColumns, Joins.TableColumns) -> some QueryExpression<Value>
83+
) -> Select<(repeat each C, Double?), From, Joins>
84+
where
85+
Columns == (repeat each C), Joins: Table,
86+
Value: _OptionalPromotable,
87+
Value._Optionalized.Wrapped: Numeric,
88+
Value._Optionalized.Wrapped: QueryRepresentable
89+
{
90+
let expr = expression(From.columns, Joins.columns)
91+
return select { _, _ in expr.avg() }
92+
}
93+
}

‎Sources/StructuredQueriesPostgres/Functions/Aggregate/Max/Select+Max.swift‎

Lines changed: 88 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,88 @@
1+
import StructuredQueriesCore
2+
3+
extension Select {
4+
/// Creates a new select statement from this one by appending a maximum aggregate to its selection.
5+
///
6+
/// ```swift
7+
/// Order.select().max { $0.amount }
8+
/// // SELECT MAX("orders"."amount") FROM "orders"
9+
/// ```
10+
///
11+
/// - Parameter expression: A closure that takes table columns and returns an expression to find the maximum of.
12+
/// - Returns: A new select statement that includes the maximum of the expression.
13+
public func max<Value>(
14+
of expression: (From.TableColumns) -> some QueryExpression<Value>
15+
) -> Select<Value._Optionalized.Wrapped?, From, ()>
16+
where
17+
Columns == (), Joins == (),
18+
Value: QueryBindable & _OptionalPromotable,
19+
Value._Optionalized.Wrapped: QueryRepresentable
20+
{
21+
let expr = expression(From.columns)
22+
return select { _ in expr.max() }
23+
}
24+
25+
/// Creates a new select statement from this one by appending a maximum aggregate to its selection (with joins).
26+
///
27+
/// - Parameter expression: A closure that takes table columns and returns an expression to find the maximum of.
28+
/// - Returns: A new select statement that includes the maximum of the expression.
29+
public func max<Value, each J: Table>(
30+
of expression: (From.TableColumns, repeat (each J).TableColumns) -> some QueryExpression<Value>
31+
) -> Select<Value._Optionalized.Wrapped?, From, (repeat each J)>
32+
where
33+
Columns == (), Joins == (repeat each J),
34+
Value: QueryBindable & _OptionalPromotable,
35+
Value._Optionalized.Wrapped: QueryRepresentable
36+
{
37+
let expr = expression(From.columns, repeat (each J).columns)
38+
return select { _ in expr.max() }
39+
}
40+
41+
/// Creates a new select statement from this one by appending a maximum aggregate to its selection (with existing columns).
42+
///
43+
/// - Parameter expression: A closure that takes table columns and returns an expression to find the maximum of.
44+
/// - Returns: A new select statement that includes the maximum of the expression.
45+
public func max<Value, each C: QueryRepresentable, each J: Table>(
46+
of expression: (From.TableColumns, repeat (each J).TableColumns) -> some QueryExpression<Value>
47+
) -> Select<(repeat each C, Value._Optionalized.Wrapped?), From, (repeat each J)>
48+
where
49+
Columns == (repeat each C), Joins == (repeat each J),
50+
Value: QueryBindable & _OptionalPromotable,
51+
Value._Optionalized.Wrapped: QueryRepresentable
52+
{
53+
let expr = expression(From.columns, repeat (each J).columns)
54+
return select { _ in expr.max() }
55+
}
56+
57+
/// Creates a new select statement from this one by appending a maximum aggregate to its selection (with single join).
58+
///
59+
/// - Parameter expression: A closure that takes table columns and returns an expression to find the maximum of.
60+
/// - Returns: A new select statement that includes the maximum of the expression.
61+
public func max<Value>(
62+
of expression: (From.TableColumns, Joins.TableColumns) -> some QueryExpression<Value>
63+
) -> Select<Value._Optionalized.Wrapped?, From, Joins>
64+
where
65+
Columns == (), Joins: Table,
66+
Value: QueryBindable & _OptionalPromotable,
67+
Value._Optionalized.Wrapped: QueryRepresentable
68+
{
69+
let expr = expression(From.columns, Joins.columns)
70+
return select { _, _ in expr.max() }
71+
}
72+
73+
/// Creates a new select statement from this one by appending a maximum aggregate to its selection (with single join and existing columns).
74+
///
75+
/// - Parameter expression: A closure that takes table columns and returns an expression to find the maximum of.
76+
/// - Returns: A new select statement that includes the maximum of the expression.
77+
public func max<Value, each C: QueryRepresentable>(
78+
of expression: (From.TableColumns, Joins.TableColumns) -> some QueryExpression<Value>
79+
) -> Select<(repeat each C, Value._Optionalized.Wrapped?), From, Joins>
80+
where
81+
Columns == (repeat each C), Joins: Table,
82+
Value: QueryBindable & _OptionalPromotable,
83+
Value._Optionalized.Wrapped: QueryRepresentable
84+
{
85+
let expr = expression(From.columns, Joins.columns)
86+
return select { _, _ in expr.max() }
87+
}
88+
}

‎Sources/StructuredQueriesPostgres/Functions/Aggregate/Min/Select+Min.swift‎

Lines changed: 88 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,88 @@
1+
import StructuredQueriesCore
2+
3+
extension Select {
4+
/// Creates a new select statement from this one by appending a minimum aggregate to its selection.
5+
///
6+
/// ```swift
7+
/// Order.select().min { $0.amount }
8+
/// // SELECT MIN("orders"."amount") FROM "orders"
9+
/// ```
10+
///
11+
/// - Parameter expression: A closure that takes table columns and returns an expression to find the minimum of.
12+
/// - Returns: A new select statement that includes the minimum of the expression.
13+
public func min<Value>(
14+
of expression: (From.TableColumns) -> some QueryExpression<Value>
15+
) -> Select<Value._Optionalized.Wrapped?, From, ()>
16+
where
17+
Columns == (), Joins == (),
18+
Value: QueryBindable & _OptionalPromotable,
19+
Value._Optionalized.Wrapped: QueryRepresentable
20+
{
21+
let expr = expression(From.columns)
22+
return select { _ in expr.min() }
23+
}
24+
25+
/// Creates a new select statement from this one by appending a minimum aggregate to its selection (with joins).
26+
///
27+
/// - Parameter expression: A closure that takes table columns and returns an expression to find the minimum of.
28+
/// - Returns: A new select statement that includes the minimum of the expression.
29+
public func min<Value, each J: Table>(
30+
of expression: (From.TableColumns, repeat (each J).TableColumns) -> some QueryExpression<Value>
31+
) -> Select<Value._Optionalized.Wrapped?, From, (repeat each J)>
32+
where
33+
Columns == (), Joins == (repeat each J),
34+
Value: QueryBindable & _OptionalPromotable,
35+
Value._Optionalized.Wrapped: QueryRepresentable
36+
{
37+
let expr = expression(From.columns, repeat (each J).columns)
38+
return select { _ in expr.min() }
39+
}
40+
41+
/// Creates a new select statement from this one by appending a minimum aggregate to its selection (with existing columns).
42+
///
43+
/// - Parameter expression: A closure that takes table columns and returns an expression to find the minimum of.
44+
/// - Returns: A new select statement that includes the minimum of the expression.
45+
public func min<Value, each C: QueryRepresentable, each J: Table>(
46+
of expression: (From.TableColumns, repeat (each J).TableColumns) -> some QueryExpression<Value>
47+
) -> Select<(repeat each C, Value._Optionalized.Wrapped?), From, (repeat each J)>
48+
where
49+
Columns == (repeat each C), Joins == (repeat each J),
50+
Value: QueryBindable & _OptionalPromotable,
51+
Value._Optionalized.Wrapped: QueryRepresentable
52+
{
53+
let expr = expression(From.columns, repeat (each J).columns)
54+
return select { _ in expr.min() }
55+
}
56+
57+
/// Creates a new select statement from this one by appending a minimum aggregate to its selection (with single join).
58+
///
59+
/// - Parameter expression: A closure that takes table columns and returns an expression to find the minimum of.
60+
/// - Returns: A new select statement that includes the minimum of the expression.
61+
public func min<Value>(
62+
of expression: (From.TableColumns, Joins.TableColumns) -> some QueryExpression<Value>
63+
) -> Select<Value._Optionalized.Wrapped?, From, Joins>
64+
where
65+
Columns == (), Joins: Table,
66+
Value: QueryBindable & _OptionalPromotable,
67+
Value._Optionalized.Wrapped: QueryRepresentable
68+
{
69+
let expr = expression(From.columns, Joins.columns)
70+
return select { _, _ in expr.min() }
71+
}
72+
73+
/// Creates a new select statement from this one by appending a minimum aggregate to its selection (with single join and existing columns).
74+
///
75+
/// - Parameter expression: A closure that takes table columns and returns an expression to find the minimum of.
76+
/// - Returns: A new select statement that includes the minimum of the expression.
77+
public func min<Value, each C: QueryRepresentable>(
78+
of expression: (From.TableColumns, Joins.TableColumns) -> some QueryExpression<Value>
79+
) -> Select<(repeat each C, Value._Optionalized.Wrapped?), From, Joins>
80+
where
81+
Columns == (repeat each C), Joins: Table,
82+
Value: QueryBindable & _OptionalPromotable,
83+
Value._Optionalized.Wrapped: QueryRepresentable
84+
{
85+
let expr = expression(From.columns, Joins.columns)
86+
return select { _, _ in expr.min() }
87+
}
88+
}

‎Sources/StructuredQueriesPostgres/Functions/Aggregate/_COVERAGE.md‎

Lines changed: 64 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -26,10 +26,10 @@ File names indicate **what they extend**, making it clear where each method live
2626
| Aggregate | Primitive | Table.X | Where.X | Select.X | Folder | Status | Notes |
2727
|--------------|-----------|---------|---------|----------|--------|--------|-------|
2828
| `count` | ✅ | ✅ | ✅ | ✅ (5) | `Count/` | ✅ | Complete coverage |
29-
| `sum` | ✅ | ❌ | ❌ | ❌ | _(in Count/)_ | 🟡 | Primitive only |
30-
| `avg` | ✅ | ❌ | ❌ | ❌ | `Avg/` | 🟡 | Column-level sufficient? |
31-
| `max` | ✅ | ❌ | ❌ | ❌ | `Max/` | 🟡 | Column-level sufficient? |
32-
| `min` | ✅ | ❌ | ❌ | ❌ | `Min/` | 🟡 | Column-level sufficient? |
29+
| `sum` | ✅ | ✅ | ✅ | ✅ (5) | `Sum/` | ✅ | Complete coverage |
30+
| `avg` | ✅ | ✅ | ✅ | ✅ (5) | `Avg/` | ✅ | Complete coverage (returns Double?) |
31+
| `max` | ✅ | ✅ | ✅ | ✅ (5) | `Max/` | ✅ | Complete coverage |
32+
| `min` | ✅ | ✅ | ✅ | ✅ (5) | `Min/` | ✅ | Complete coverage |
3333
| `total` | ✅ | ❌ | ❌ | ❌ | `Total/` | 🟡 | Low priority (SQLite-specific) |
3434
| `groupConcat`| ✅ | ❌ | ❌ | ❌ | `GroupConcat/` | 🟡 | Low priority (complex args) |
3535

@@ -92,3 +92,63 @@ Due to Swift's type system, each Select.aggregate method requires 5 overloads:
9292
4. Repeat for Where and Select
9393
5. Update this coverage matrix
9494
6. Build & test
95+
96+
## PostgreSQL Chapter 9 Coverage (Functions Outside Aggregates)
97+
98+
### ✅ Implemented (Excellent Coverage)
99+
- 9.2: Comparison Functions (ComparisonFunctions.swift)
100+
- 9.3: Mathematical Functions (6 files)
101+
- 9.4: String Functions (11 files under PostgreSQL.String namespace)
102+
- 9.5: Binary String Functions
103+
- 9.7: Pattern Matching (LIKE, SIMILAR TO, POSIX regex)
104+
- 9.8: Data Type Formatting
105+
- 9.9: Date/Time Functions (3 files: Extract, Truncate, Current)
106+
- 9.13: Full Text Search (5 files)
107+
- 9.16: JSON Functions (5 files)
108+
- 9.18: Conditional Expressions (CASE, COALESCE, NULLIF)
109+
- 9.19: Array Functions (4 files under PostgreSQL.Array namespace)
110+
- 9.21: Aggregate Functions (this file)
111+
- 9.22: Window Functions (4 files)
112+
- 9.24: Subquery Expressions (ANY, ALL, EXISTS, IN)
113+
- 9.26: Set Returning Functions
114+
115+
### ❌ Intentionally Skipped (With Rationale)
116+
117+
**9.6: Bit String Functions**
118+
- **Reason**: PostgreSQL BIT/BIT VARYING types don't map cleanly to Swift
119+
- **Alternative**: Use Int bitwise operators (which we have) or Data in Swift
120+
- **Use Case**: Legacy binary manipulation - rare in modern type-safe systems
121+
122+
**9.10: PostgreSQL ENUM Functions** (enum_first, enum_last, enum_range)
123+
- **Reason**: Incompatible with our superior Swift enum-as-table pattern
124+
- **Alternative**: We have `@Table enum` with associated values (PostgreSQL ENUMs can't do this)
125+
- **Use Case**: Our CasePaths integration provides better type safety
126+
127+
**9.11: Geometric Functions**
128+
- **Reason**: Niche use case (GIS applications)
129+
- **Strategy**: Wait for user request before implementing
130+
131+
**9.12: Network Address Functions**
132+
- **Reason**: Specialized networking use case
133+
- **Strategy**: Wait for user request before implementing
134+
135+
**9.14: XML Functions**
136+
- **Reason**: XML is declining in favor of JSON (which we fully support)
137+
- **Strategy**: User request only
138+
139+
**9.17: Sequence Manipulation Functions**
140+
- **Reason**: Medium priority - useful for nextval/currval
141+
- **Strategy**: Implement when users need manual sequence control
142+
143+
**9.20: Range/Multirange Functions**
144+
- **Reason**: Specialized data type
145+
- **Strategy**: Wait for user request
146+
147+
**9.23: System Information Functions**
148+
- **Reason**: Administration/introspection, not query building
149+
- **Strategy**: Out of scope for this package
150+
151+
### Coverage Summary
152+
- **Core SQL**: ~95% of commonly-used functions implemented
153+
- **Skipped**: Niche types, administration, and features superseded by better Swift patterns
154+
- **Philosophy**: Maximize value per line of code, wait for real-world usage to guide additions

0 commit comments

Comments
 (0)