func NewOrderWithLimit(order *algebra.Order, offset *Offset, limit *Limit) *Order {
return &Order{
terms: order.Terms(),
offset: offset,
limit: limit,
}
}
func NewOrder(order *algebra.Order) *Order {
return &Order{
terms: order.Terms(),
offset: nil,
limit: nil,
}
}
func allAggregates(node *algebra.Subselect, order *algebra.Order) (map[string]algebra.Aggregate, error) {
aggs := make(map[string]algebra.Aggregate)
if node.Let() != nil {
for _, binding := range node.Let() {
collectAggregates(aggs, binding.Expression())
if len(aggs) > 0 {
return nil, fmt.Errorf("Aggregates not allowed in LET.")
}
}
}
if node.Where() != nil {
collectAggregates(aggs, node.Where())
if len(aggs) > 0 {
return nil, fmt.Errorf("Aggregates not allowed in WHERE.")
}
}
group := node.Group()
if group != nil {
letting := group.Letting()
for _, binding := range letting {
collectAggregates(aggs, binding.Expression())
}
having := group.Having()
if having != nil {
collectAggregates(aggs, having)
}
}
projection := node.Projection()
if projection != nil {
for _, term := range projection.Terms() {
if term.Expression() != nil {
collectAggregates(aggs, term.Expression())
}
}
}
if order != nil {
allow := len(aggs) > 0
for _, term := range order.Terms() {
if term.Expression() != nil {
collectAggregates(aggs, term.Expression())
}
}
if !allow && len(aggs) > 0 {
return nil, fmt.Errorf("Aggregates not available for this ORDER BY.")
}
}
return aggs, nil
}
func NewOrder(order *algebra.Order) *Order {
return &Order{
terms: order.Terms(),
}
}