         self.evaluator = ExpressionEvaluator(base: base)
         self.freshCounter = sequence(first: 1) { $0 + 1 }
         self.allowStoreOptimizedPlans = true
+        self.verbose = false
     }
     
     public func freshVariable() -> Node {

public class QueryPlanner<Q: QuadStoreProtocol> {
    public var allowStoreOptimizedPlans: Bool
    public var store: Q
    public var dataset: Dataset
    public var evaluator: ExpressionEvaluator
    private var freshCounter: UnfoldSequence<Int, (Int?, Bool)>

            let p = try plan(algebra: child, activeGraph: activeGraph)
            return AggregationPlan(child: p, groups: groups, aggregates: aggs)
        case let .window(child, funcs):
            guard funcs.count == 1, let f = funcs.first else {
                let pp = funcs.reduce(child) { Algebra.window($0, [$1]) }
                return try plan(algebra: pp, activeGraph: activeGraph)
            }
            let p = try plan(algebra: child, activeGraph: activeGraph)
            
            let app = f.windowApplication
            let partitionComparators = app.partition.map { Algebra.SortComparator(ascending: true, expression: $0) }
