code: func (a *aggregationEliminateChecker) tryToEliminateAggregation(agg *LogicalAggregation) *LogicalProjection {
  	for _, af := range agg.AggFuncs {
  		// TODO(issue #9968): Actually, we can rewrite GROUP_CONCAT when all the
  		// arguments it accepts are promised to be NOT-NULL.
  		// When it accepts only 1 argument, we can extract this argument into a
  		// projection.
  		// When it accepts multiple arguments, we can wrap the arguments with a
  		// function CONCAT_WS and extract this function into a projection.
  		// BUT, GROUP_CONCAT should truncate the final result according to the
  		// system variable `group_concat_max_len`. To ensure the correctness of
  		// the result, we close the elimination of GROUP_CONCAT here.
  		if af.Name == ast.AggFuncGroupConcat {
  			return nil
  		}
  	}
  	schemaByGroupby := expression.NewSchema(agg.groupByCols...)
  	coveredByUniqueKey := false
  	for _, key := range agg.children[0].Schema().Keys {
  		if schemaByGroupby.ColumnsIndices(key) != nil {
  			coveredByUniqueKey = true
  			break
  		}
  	}
  	if coveredByUniqueKey {
  		// GroupByCols has unique key, so this aggregation can be removed.
  		proj := a.convertAggToProj(agg)
  		proj.SetChildren(agg.children[0])
  		return proj
  	}
  	return nil
  }
docs: // tryToEliminateAggregation will eliminate aggregation grouped by unique key.
  // e.g. select min(b) from t group by a. If a is a unique key, then this sql is equal to `select b from t group by a`.
  // For count(expr), sum(expr), avg(expr), count(distinct expr, [expr...]) we may need to rewrite the expr. Details are shown below.
  // If we can eliminate agg successful, we return a projection. Else we return a nil pointer.