///|
/// A bounded shortcut for unfiltered aggregates of physical columns/constants.
/// Resolve positions once, then share one row scan across the aggregates.
fn simple_aggregate(
select : Selection,
context : Evaluation,
output : Environment,
) -> Relation? raise SqlError {
guard context.store.encoding.unwrap_or(1) == 1 &&
select.sources.length() == 1 &&
select.ctes.is_empty() &&
context.ctes.length() == 0 &&
!select.distinct &&
select.groups.is_empty() &&
select.having is Literal(Integer(1L)) &&
select.predicate is Literal(Integer(1L)) &&
select.orders.is_empty() else {
return None
}
let source = select.sources[0]
guard !source.left &&
source.right != Some(true) &&
source.on is Literal(Integer(1L)) else {
return None
}
let names : Array[String] = []
let projections : Array[Projection] = []
for p in select.projections {
guard p.expression is Call(name, [arg]) &&
["count", "sum", "total", "avg"].contains(name) else {
return None
}
names.push(name)
projections.push({
..p,
expression: if arg is Star(_) {
Literal(Integer(1L))
} else {
arg
},
})
}
let mut physical : Table? = None
for table in context.store.tables {
if matches_identifier(table.name, identifier(source.name)) {
physical = Some(table)
break
}
}
guard physical is Some(table) && !table.without_rowid else { return None }
guard simple_projection({ ..select, projections, }, table, source.qualifier)
is Some(plan) else {
return None
}
guard rowid_value(select.limit, context.params) is Some(limit) &&
rowid_value(select.offset, context.params) is Some(offset) else {
return None
}
if limit == 0L {
return Some({ rows: [], template: output, })
}
let states = names.map(_ => sum_state())
let rows = ordered_rowid_rows(context.store, table)
for row in rows {
for i, field in plan {
let value = match field {
Stored(n) => row.values[n]
RowidValue => Value::Integer(row.id)
Constant(v) => v
}
if names[i] == "count" {
if !(value is Null) {
states[i].count += 1L
}
} else {
states[i].add(value)
}
}
}
let values : Array[Value] = names.mapi((i, name) => {
if name == "count" {
Integer(states[i].count)
} else {
states[i].finish(name)
}
})
Some({
rows: if offset > 0L {
[]
} else {
[output.mapi((i, b) => { ..b, value: values[i], })]
},
template: output,
})
}
///|
fn ordered_rowid_rows(
store : Store,
table : Table,
) -> Array[StoredRow] raise SqlError {
index_rows_for_fields(
store,
table,
"\u{0}rowid:" + table.name,
[{ column: -1, collation: "binary", descending: false, }],
None,
)
}