SQL: selecting a literal from grouped by query generates error

x-pack/plugin/sql/qa/src/main/resources/agg.sql-spec

@@ -144,6 +144,9 @@ countDistinctAlias
 SELECT COUNT(DISTINCT hire_date) AS count FROM test_emp;
 countDistinctAndCountSimpleWithAlias
 SELECT COUNT(*) cnt, COUNT(DISTINCT first_name) as names, gender FROM test_emp GROUP BY gender ORDER BY gender;
+countWithFunctionFilterAndGroupBy
+SELECT COUNT(*) as c FROM test_emp WHERE ABS(salary) > 0 GROUP BY gender ORDER BY gender;
+
 
 aggCountAliasAndWhereClauseMultiGroupBy
 SELECT gender g, languages l, COUNT(*) c FROM "test_emp" WHERE emp_no < 10020 GROUP BY gender, languages ORDER BY gender, languages;
@@ -348,7 +351,7 @@ SELECT gender g, MAX(emp_no) m FROM "test_emp" GROUP BY g HAVING MAX(emp_no) > 1
 aggMaxWithHavingOnAlias
 SELECT gender g, MAX(emp_no) m FROM "test_emp" GROUP BY g HAVING m > 10 ORDER BY g ;
 aggMaxWithMultipleHaving
-SELECT gender g, MAX(emp_no) m FROM "test_emp" GROUP BY g HAVING m > 10 AND m < 99999 ORDER BY gender; 
+SELECT gender g, MAX(emp_no) m FROM "test_emp" GROUP BY g HAVING m > 10 AND m < 99999 ORDER BY gender;
 aggMaxWithMultipleHavingBetween
 SELECT gender g, MAX(emp_no) m FROM "test_emp" GROUP BY g HAVING m BETWEEN 10 AND 99999 ORDER BY g ;
 aggMaxWithMultipleHavingWithLimit
@@ -435,7 +438,7 @@ SELECT 1 FROM test_emp HAVING COUNT(*) > 0;
 implicitGroupingWithLiteralAliasAndFiltering
 SELECT 1 AS l FROM test_emp HAVING COUNT(*) > 0;
 implicitGroupingWithLiteralAndFilteringOnAlias
-SELECT 1, COUNT(*) AS c FROM test_emp HAVING c > 0; 
+SELECT 1, COUNT(*) AS c FROM test_emp HAVING c > 0;
 implicitGroupingWithLiteralAliasAndFilteringOnAlias
 SELECT 1 AS l FROM test_emp HAVING COUNT(*) > 0;
 implicitGroupingWithAggs
@@ -497,7 +500,7 @@ SELECT MIN(salary) mi, MAX(salary) ma, MAX(salary) - MIN(salary) AS d FROM test_
 
 
 //
-// Mixture of aggs that get promoted plus filtering on one of them 
+// Mixture of aggs that get promoted plus filtering on one of them
 //
 aggMultiWithHaving
 SELECT MIN(salary) min, MAX(salary) max, gender g, COUNT(*) c FROM "test_emp" WHERE languages > 0 GROUP BY g HAVING max > 74600 ORDER BY gender;
@@ -563,5 +566,7 @@ SELECT MIN(salary) min, MAX(salary) max, gender g, languages l, COUNT(*) c FROM
 // group by with literal
 implicitGroupByWithLiteral
 SELECT 10, MAX("salary") FROM test_emp;
+literalWithGroupBy
+SELECT 1 FROM test_emp GROUP BY gender;
 groupByWithLiteralAndCount
 SELECT 20, COUNT(*) from test_emp GROUP BY gender ORDER BY 2;

x-pack/plugin/sql/src/main/java/org/elasticsearch/xpack/sql/analysis/analyzer/Analyzer.java

@@ -14,6 +14,7 @@
 import org.elasticsearch.xpack.ql.expression.Expression;
 import org.elasticsearch.xpack.ql.expression.Expressions;
 import org.elasticsearch.xpack.ql.expression.FieldAttribute;
+import org.elasticsearch.xpack.ql.expression.Literal;
 import org.elasticsearch.xpack.ql.expression.NamedExpression;
 import org.elasticsearch.xpack.ql.expression.Order;
 import org.elasticsearch.xpack.ql.expression.ReferenceAttribute;
@@ -70,6 +71,7 @@
 import static java.util.Collections.emptyList;
 import static java.util.Collections.singletonList;
 import static java.util.stream.Collectors.toList;
+import static java.util.stream.Collectors.toSet;
 import static org.elasticsearch.xpack.ql.util.CollectionUtils.combine;
 
 public class Analyzer extends RuleExecutor<LogicalPlan> {
@@ -341,6 +343,22 @@ else if (plan instanceof Aggregate) {
                     List<Expression> groupings = a.groupings();
                     List<Expression> newGroupings = new ArrayList<>();
                     AttributeMap<Expression> resolved = Expressions.aliases(a.aggregates());
+
+                    //if all we're selecting are functions or literals, even if we're giving them aliases.
+                    final boolean[] updateResolved = {true};
+                    a.forEachUp(p -> p.forEachExpressionsUp(e -> {
+                        if (e instanceof Alias
+                            && ((Alias) e).child() instanceof Function == false
+                            && ((Alias) e).child() instanceof Literal == false) {
+                            updateResolved[0] = false;
+                        }
+                    }));
+                    if(updateResolved[0]){
+                        var allFields = plan.inputSet().stream().map(NamedExpression.class::cast)
+                            .collect(toList());
+                        allFields.addAll(a.aggregates());
+                        resolved = Expressions.asAttributeMap(allFields);
+                    }
                     boolean changed = false;
                     for (Expression grouping : groupings) {
                         if (grouping instanceof UnresolvedAttribute) {
@@ -618,7 +636,7 @@ protected LogicalPlan rule(LogicalPlan plan) {
                 for (Order or : o.order()) {
                     maybeResolved.add(or.resolved() ? or : tryResolveExpression(or, child));
                 }
-                
+
                 Stream<Order> referencesStream = maybeResolved.stream()
                         .filter(Expression::resolved);
 
@@ -629,7 +647,7 @@ protected LogicalPlan rule(LogicalPlan plan) {
                 // a + 1 in SELECT is actually Alias("a + 1", a + 1) and translates to ReferenceAttribute
                 // in the output. However it won't match the unnamed a + 1 despite being the same expression
                 // so explicitly compare the source
-                
+
                 // if there's a match, remove the item from the reference stream
                 if (Expressions.hasReferenceAttribute(child.outputSet())) {
                     final Map<Attribute, Expression> collectRefs = new LinkedHashMap<>();

x-pack/plugin/sql/src/main/java/org/elasticsearch/xpack/sql/optimizer/Optimizer.java

@@ -94,6 +94,7 @@
 import java.util.Set;
 import java.util.function.Consumer;
 
+import static java.util.Collections.emptyList;
 import static java.util.Collections.singletonList;
 import static org.elasticsearch.xpack.ql.expression.Expressions.equalsAsAttribute;
 import static org.elasticsearch.xpack.ql.expression.Literal.FALSE;
@@ -2112,7 +2113,7 @@ protected LogicalPlan rule(LogicalPlan plan) {
 
             plan.forEachDown(a -> {
                 List<Object> values = extractConstants(a.aggregates());
-                if (values.size() == a.aggregates().size() && isNotQueryWithFromClauseAndFilterFoldedToFalse(a)) {
+                if (values.size() == a.aggregates().size() && a.groupings().isEmpty() && isNotQueryWithFromClauseAndFilterFoldedToFalse(a)) {
                     optimizedPlan.set(new LocalRelation(a.source(), new SingletonExecutable(a.output(), values.toArray())));
                 }
             }, Aggregate.class);

x-pack/plugin/sql/src/main/java/org/elasticsearch/xpack/sql/planner/QueryFolder.java

@@ -392,11 +392,11 @@ protected PhysicalPlan rule(AggregateExec a) {
             }
             return a;
         }
-        
+
         static EsQueryExec fold(AggregateExec a, EsQueryExec exec) {
-            
+
             QueryContainer queryC = exec.queryContainer();
-            
+
             // track aliases defined in the SELECT and used inside GROUP BY
             // SELECT x AS a ... GROUP BY a
             Map<Attribute, Expression> aliasMap = new LinkedHashMap<>();
@@ -405,7 +405,7 @@ static EsQueryExec fold(AggregateExec a, EsQueryExec exec) {
                     aliasMap.put(ne.toAttribute(), ((Alias) ne).child());
                 }
             }
-            
+
             if (aliasMap.isEmpty() == false) {
                 Map<Attribute, Expression> newAliases = new LinkedHashMap<>(queryC.aliases());
                 newAliases.putAll(aliasMap);
@@ -455,6 +455,13 @@ static EsQueryExec fold(AggregateExec a, EsQueryExec exec) {
                 // literal
                 if (target.foldable()) {
                     queryC = queryC.addColumn(ne.toAttribute());
+                    //If we're only selecting literals, we have to fix the row count
+                    if(a.aggregates().stream().allMatch(s -> s.children().get(0) instanceof Literal)) {
+                        for (Expression grouping : a.groupings()) {
+                            GroupByKey matchingGroup = groupingContext.groupFor(grouping);
+                            queryC = queryC.addColumn(new GroupByRef(matchingGroup.id(), null, false), id);
+                        }
+                    }
                 }
 
                 // look at functions

x-pack/plugin/sql/src/test/java/org/elasticsearch/xpack/sql/planner/QueryTranslatorTests.java

@@ -16,7 +16,10 @@
 import org.elasticsearch.xpack.ql.expression.Expression;
 import org.elasticsearch.xpack.ql.expression.FieldAttribute;
 import org.elasticsearch.xpack.ql.expression.Literal;
+import org.elasticsearch.xpack.ql.expression.NamedExpression;
+import org.elasticsearch.xpack.ql.expression.function.aggregate.Count;
 import org.elasticsearch.xpack.ql.expression.gen.script.ScriptTemplate;
+import org.elasticsearch.xpack.ql.expression.predicate.operator.comparison.GreaterThan;
 import org.elasticsearch.xpack.ql.index.EsIndex;
 import org.elasticsearch.xpack.ql.index.IndexResolution;
 import org.elasticsearch.xpack.ql.plan.logical.Aggregate;
@@ -130,6 +133,29 @@ public void testTermEqualityAnalyzer() {
         assertEquals("value", tq.value());
     }
 
+    public void testAliasAndGroupByResolution(){
+        LogicalPlan p = plan("SELECT COUNT(*) AS c FROM test WHERE ABS(int) > 0 GROUP BY int");
+        assertTrue(p instanceof Aggregate);
+        var pc = ((Aggregate) p).child();
+        assertTrue(pc instanceof Filter);
+        Expression condition = ((Filter) pc).condition();
+        assertEquals(((GreaterThan) condition).functionName(), "GREATERTHAN");
+        List<Expression> groupings = ((Aggregate) p).groupings();
+        assertTrue(groupings.get(0).resolved());
+        var agg = ((Aggregate) p).aggregates();
+        assertEquals((agg.get(0)).name(), "c");
+        assertEquals(((Count) ((Alias) agg.get(0)).child()).functionName(), "COUNT");
+    }
+    public void testLiteralWithGroupBy(){
+        LogicalPlan p = plan("SELECT 1 as t FROM test GROUP BY int");
+        assertTrue(p instanceof Aggregate);
+        List<Expression> groupings = ((Aggregate) p).groupings();
+        assertTrue(groupings.get(0).resolved());
+        var agg = ((Aggregate) p).aggregates();
+        assertEquals((agg.get(0)).name(), "t");
+        assertTrue(((Alias) agg.get(0)).child() instanceof Literal);
+    }
+
     public void testTermEqualityNotAnalyzed() {
         LogicalPlan p = plan("SELECT some.string FROM test WHERE int = 5");
         assertTrue(p instanceof Project);