@Override
        public LogicalPlan apply(LogicalPlan oldPlan) {
            return oldPlan.resolveOperators(plan -> {
                if (!plan.childrenResolved()) {
                    return plan;
                }
                // If the projection list contains Stars, expand it.
                if (plan instanceof Project) {
                    Project p = (Project) plan;
                    List<NamedExpression> projectList = p.projectList;
                    LogicalPlan child = p.child();
                    if (containsStar(projectList)) {
                        List<NamedExpression> newProjectList = flatMapToList(projectList, e -> {
                            if (e instanceof Star) {
                                return ((Star) e).expand(child, resolver);
                            }
                            return Collections.singletonList(e);
                        });
                        return new Project(newProjectList, p.child());
                    }
                }
                if (plan instanceof Aggregate) {
                    Aggregate agg = (Aggregate) plan;
                    List<NamedExpression> aggs = agg.aggregateExpressions;
                    if (containsStar(aggs)) {
                        return new Aggregate(
                                agg.groupingExpressions,
                                mapToList(expandStarExpressions(aggs, agg.child()), e -> (NamedExpression) e),
                                agg.child());
                    }
                }
                if (plan instanceof Sort) {
                    Sort sort = (Sort) plan;
                    if (sort.child().resolved() && !sort.resolved()) {
                        List<SortOrder> newOrdering = resolveSortOrders(sort.order, sort.child());
                        return new Sort(newOrdering, sort.child());
                    }
                }
                return plan.transformExpressionsUp(p -> {
                    if (p instanceof UnresolvedAttribute) {
                        NamedExpression result = plan.resolveChildren(((UnresolvedAttribute) p).name(), resolver);
                        log.trace("Resolving {} to {}", p, result);
                        if (result != null) {
                            return result;
                        }
                    }
                    return p;
                });
            });
        }
Returns true if `exprs` contains a [[Star]].
indexr-query-opt/src/main/java/io/indexr/query/Analyzer.java