{s:`SELECT value FROM cpu WHERE value`,err:`invalid condition expression: value`},
{s:`SELECT count(value), * FROM cpu`,err:`mixing aggregate and non-aggregate queries is not supported`},
{s:`SELECT max(*), host FROM cpu`,err:`mixing aggregate and non-aggregate queries is not supported`},
{s:`SELECT count(value), /ho/ FROM cpu`,err:`mixing aggregate and non-aggregate queries is not supported`},
{s:`SELECT max(/val/), * FROM cpu`,err:`mixing aggregate and non-aggregate queries is not supported`},
{s:`SELECT a(value) FROM cpu`,err:`undefined function a()`},
{s:`SELECT count(max(value)) FROM myseries`,err:`expected field argument in count()`},
{s:`SELECT count(distinct('value')) FROM myseries`,err:`expected field argument in distinct()`},
{s:`SELECT distinct('value') FROM myseries`,err:`expected field argument in distinct()`},
{s:`SELECT min(max(value)) FROM myseries`,err:`expected field argument in min()`},
{s:`SELECT min(distinct(value)) FROM myseries`,err:`expected field argument in min()`},
{s:`SELECT max(max(value)) FROM myseries`,err:`expected field argument in max()`},
{s:`SELECT sum(max(value)) FROM myseries`,err:`expected field argument in sum()`},
{s:`SELECT first(max(value)) FROM myseries`,err:`expected field argument in first()`},
{s:`SELECT last(max(value)) FROM myseries`,err:`expected field argument in last()`},
{s:`SELECT mean(max(value)) FROM myseries`,err:`expected field argument in mean()`},
{s:`SELECT median(max(value)) FROM myseries`,err:`expected field argument in median()`},
{s:`SELECT mode(max(value)) FROM myseries`,err:`expected field argument in mode()`},
{s:`SELECT stddev(max(value)) FROM myseries`,err:`expected field argument in stddev()`},
{s:`SELECT spread(max(value)) FROM myseries`,err:`expected field argument in spread()`},
{s:`SELECT top() FROM myseries`,err:`invalid number of arguments for top, expected at least 2, got 0`},
{s:`SELECT top(field1) FROM myseries`,err:`invalid number of arguments for top, expected at least 2, got 1`},
{s:`SELECT top(field1,foo) FROM myseries`,err:`expected integer as last argument in top(), found foo`},
{s:`SELECT top(field1,host,'server',foo) FROM myseries`,err:`expected integer as last argument in top(), found foo`},
{s:`SELECT top(field1,5,'server',2) FROM myseries`,err:`only fields or tags are allowed in top(), found 5`},
{s:`SELECT top(field1,max(foo),'server',2) FROM myseries`,err:`only fields or tags are allowed in top(), found max(foo)`},
{s:`SELECT top(value, 10) + count(value) FROM myseries`,err:`selector function top() cannot be combined with other functions`},
{s:`SELECT top(max(value), 10) FROM myseries`,err:`expected first argument to be a field in top(), found max(value)`},
{s:`SELECT bottom() FROM myseries`,err:`invalid number of arguments for bottom, expected at least 2, got 0`},
{s:`SELECT bottom(field1) FROM myseries`,err:`invalid number of arguments for bottom, expected at least 2, got 1`},
{s:`SELECT bottom(field1,foo) FROM myseries`,err:`expected integer as last argument in bottom(), found foo`},
{s:`SELECT bottom(field1,host,'server',foo) FROM myseries`,err:`expected integer as last argument in bottom(), found foo`},
{s:`SELECT bottom(field1,5,'server',2) FROM myseries`,err:`only fields or tags are allowed in bottom(), found 5`},
{s:`SELECT bottom(field1,max(foo),'server',2) FROM myseries`,err:`only fields or tags are allowed in bottom(), found max(foo)`},
{s:`SELECT bottom(value, 10) + count(value) FROM myseries`,err:`selector function bottom() cannot be combined with other functions`},
{s:`SELECT bottom(max(value), 10) FROM myseries`,err:`expected first argument to be a field in bottom(), found max(value)`},
{s:`SELECT top(value, 10), bottom(value, 10) FROM cpu`,err:`selector function top() cannot be combined with other functions`},
{s:`SELECT bottom(value, 10), top(value, 10) FROM cpu`,err:`selector function bottom() cannot be combined with other functions`},
{s:`SELECT sample(value) FROM myseries`,err:`invalid number of arguments for sample, expected 2, got 1`},
{s:`SELECT sample(value, 2, 3) FROM myseries`,err:`invalid number of arguments for sample, expected 2, got 3`},
{s:`SELECT sample(value, 0) FROM myseries`,err:`sample window must be greater than 1, got 0`},
{s:`SELECT sample(value, 2.5) FROM myseries`,err:`expected integer argument in sample()`},
{s:`SELECT percentile() FROM myseries`,err:`invalid number of arguments for percentile, expected 2, got 0`},
{s:`SELECT percentile(field1) FROM myseries`,err:`invalid number of arguments for percentile, expected 2, got 1`},
{s:`SELECT percentile(field1, foo) FROM myseries`,err:`expected float argument in percentile()`},
{s:`SELECT percentile(max(field1), 75) FROM myseries`,err:`expected field argument in percentile()`},
{s:`SELECT field1 FROM foo group by time(1s)`,err:`GROUP BY requires at least one aggregate function`},
{s:`SELECT field1 FROM foo fill(none)`,err:`fill(none) must be used with a function`},
{s:`SELECT field1 FROM foo fill(linear)`,err:`fill(linear) must be used with a function`},
{s:`SELECT count(value), value FROM foo`,err:`mixing aggregate and non-aggregate queries is not supported`},
{s:`SELECT count(value) FROM foo group by time`,err:`time() is a function and expects at least one argument`},
{s:`SELECT count(value) FROM foo group by 'time'`,err:`only time and tag dimensions allowed`},
{s:`SELECT count(value) FROM foo where time > now() and time < now() group by time()`,err:`time dimension expected 1 or 2 arguments`},
{s:`SELECT count(value) FROM foo where time > now() and time < now() group by time(b)`,err:`time dimension must have duration argument`},
{s:`SELECT count(value) FROM foo where time > now() and time < now() group by time(1s), time(2s)`,err:`multiple time dimensions not allowed`},
{s:`SELECT count(value) FROM foo where time > now() and time < now() group by time(1s, b)`,err:`time dimension offset must be duration or now()`},
{s:`SELECT count(value) FROM foo where time > now() and time < now() group by time(1s, '5s')`,err:`time dimension offset must be duration or now()`},
{s:`SELECT distinct(field1), sum(field1) FROM myseries`,err:`aggregate function distinct() cannot be combined with other functions or fields`},
{s:`SELECT distinct(field1), field2 FROM myseries`,err:`aggregate function distinct() cannot be combined with other functions or fields`},
{s:`SELECT distinct(field1, field2) FROM myseries`,err:`distinct function can only have one argument`},
{s:`SELECT distinct() FROM myseries`,err:`distinct function requires at least one argument`},
{s:`SELECT distinct field1, field2 FROM myseries`,err:`aggregate function distinct() cannot be combined with other functions or fields`},
{s:`SELECT count(distinct field1, field2) FROM myseries`,err:`invalid number of arguments for count, expected 1, got 2`},
{s:`select count(distinct(too, many, arguments)) from myseries`,err:`distinct function can only have one argument`},
{s:`select count() from myseries`,err:`invalid number of arguments for count, expected 1, got 0`},
{s:`SELECT derivative(field1), field1 FROM myseries`,err:`mixing aggregate and non-aggregate queries is not supported`},
{s:`select derivative() from myseries`,err:`invalid number of arguments for derivative, expected at least 1 but no more than 2, got 0`},
{s:`select derivative(mean(value), 1h, 3) from myseries`,err:`invalid number of arguments for derivative, expected at least 1 but no more than 2, got 3`},
{s:`SELECT derivative(value) FROM myseries group by time(1h)`,err:`aggregate function required inside the call to derivative`},
{s:`SELECT derivative(top(value)) FROM myseries where time < now() and time > now() - 1d group by time(1h)`,err:`invalid number of arguments for top, expected at least 2, got 1`},
{s:`SELECT derivative(bottom(value)) FROM myseries where time < now() and time > now() - 1d group by time(1h)`,err:`invalid number of arguments for bottom, expected at least 2, got 1`},
{s:`SELECT derivative(max()) FROM myseries where time < now() and time > now() - 1d group by time(1h)`,err:`invalid number of arguments for max, expected 1, got 0`},
{s:`SELECT derivative(percentile(value)) FROM myseries where time < now() and time > now() - 1d group by time(1h)`,err:`invalid number of arguments for percentile, expected 2, got 1`},
{s:`SELECT derivative(mean(value), 1h) FROM myseries where time < now() and time > now() - 1d`,err:`derivative aggregate requires a GROUP BY interval`},
{s:`SELECT derivative(value, -2h) FROM myseries`,err:`duration argument must be positive, got -2h`},
{s:`SELECT derivative(value, 10) FROM myseries`,err:`second argument to derivative must be a duration, got *influxql.IntegerLiteral`},
{s:`SELECT derivative(f, true) FROM myseries`,err:`second argument to derivative must be a duration, got *influxql.BooleanLiteral`},
{s:`SELECT non_negative_derivative(field1), field1 FROM myseries`,err:`mixing aggregate and non-aggregate queries is not supported`},
{s:`select non_negative_derivative() from myseries`,err:`invalid number of arguments for non_negative_derivative, expected at least 1 but no more than 2, got 0`},
{s:`select non_negative_derivative(mean(value), 1h, 3) from myseries`,err:`invalid number of arguments for non_negative_derivative, expected at least 1 but no more than 2, got 3`},
{s:`SELECT non_negative_derivative(value) FROM myseries group by time(1h)`,err:`aggregate function required inside the call to non_negative_derivative`},
{s:`SELECT non_negative_derivative(top(value)) FROM myseries where time < now() and time > now() - 1d group by time(1h)`,err:`invalid number of arguments for top, expected at least 2, got 1`},
{s:`SELECT non_negative_derivative(bottom(value)) FROM myseries where time < now() and time > now() - 1d group by time(1h)`,err:`invalid number of arguments for bottom, expected at least 2, got 1`},
{s:`SELECT non_negative_derivative(max()) FROM myseries where time < now() and time > now() - 1d group by time(1h)`,err:`invalid number of arguments for max, expected 1, got 0`},
{s:`SELECT non_negative_derivative(mean(value), 1h) FROM myseries where time < now() and time > now() - 1d`,err:`non_negative_derivative aggregate requires a GROUP BY interval`},
{s:`SELECT non_negative_derivative(percentile(value)) FROM myseries where time < now() and time > now() - 1d group by time(1h)`,err:`invalid number of arguments for percentile, expected 2, got 1`},
{s:`SELECT non_negative_derivative(value, -2h) FROM myseries`,err:`duration argument must be positive, got -2h`},
{s:`SELECT non_negative_derivative(value, 10) FROM myseries`,err:`second argument to non_negative_derivative must be a duration, got *influxql.IntegerLiteral`},
{s:`SELECT difference(field1), field1 FROM myseries`,err:`mixing aggregate and non-aggregate queries is not supported`},
{s:`SELECT difference() from myseries`,err:`invalid number of arguments for difference, expected 1, got 0`},
{s:`SELECT difference(value) FROM myseries group by time(1h)`,err:`aggregate function required inside the call to difference`},
{s:`SELECT difference(top(value)) FROM myseries where time < now() and time > now() - 1d group by time(1h)`,err:`invalid number of arguments for top, expected at least 2, got 1`},
{s:`SELECT difference(bottom(value)) FROM myseries where time < now() and time > now() - 1d group by time(1h)`,err:`invalid number of arguments for bottom, expected at least 2, got 1`},
{s:`SELECT difference(max()) FROM myseries where time < now() and time > now() - 1d group by time(1h)`,err:`invalid number of arguments for max, expected 1, got 0`},
{s:`SELECT difference(percentile(value)) FROM myseries where time < now() and time > now() - 1d group by time(1h)`,err:`invalid number of arguments for percentile, expected 2, got 1`},
{s:`SELECT difference(mean(value)) FROM myseries where time < now() and time > now() - 1d`,err:`difference aggregate requires a GROUP BY interval`},
{s:`SELECT non_negative_difference(field1), field1 FROM myseries`,err:`mixing aggregate and non-aggregate queries is not supported`},
{s:`SELECT non_negative_difference() from myseries`,err:`invalid number of arguments for non_negative_difference, expected 1, got 0`},
{s:`SELECT non_negative_difference(value) FROM myseries group by time(1h)`,err:`aggregate function required inside the call to non_negative_difference`},
{s:`SELECT non_negative_difference(top(value)) FROM myseries where time < now() and time > now() - 1d group by time(1h)`,err:`invalid number of arguments for top, expected at least 2, got 1`},
{s:`SELECT non_negative_difference(bottom(value)) FROM myseries where time < now() and time > now() - 1d group by time(1h)`,err:`invalid number of arguments for bottom, expected at least 2, got 1`},
{s:`SELECT non_negative_difference(max()) FROM myseries where time < now() and time > now() - 1d group by time(1h)`,err:`invalid number of arguments for max, expected 1, got 0`},
{s:`SELECT non_negative_difference(percentile(value)) FROM myseries where time < now() and time > now() - 1d group by time(1h)`,err:`invalid number of arguments for percentile, expected 2, got 1`},
{s:`SELECT non_negative_difference(mean(value)) FROM myseries where time < now() and time > now() - 1d`,err:`non_negative_difference aggregate requires a GROUP BY interval`},
{s:`SELECT elapsed() FROM myseries`,err:`invalid number of arguments for elapsed, expected at least 1 but no more than 2, got 0`},
{s:`SELECT elapsed(value) FROM myseries group by time(1h)`,err:`aggregate function required inside the call to elapsed`},
{s:`SELECT elapsed(value, 1s, host) FROM myseries`,err:`invalid number of arguments for elapsed, expected at least 1 but no more than 2, got 3`},
{s:`SELECT elapsed(value, 0s) FROM myseries`,err:`duration argument must be positive, got 0s`},
{s:`SELECT elapsed(value, -10s) FROM myseries`,err:`duration argument must be positive, got -10s`},
{s:`SELECT elapsed(value, 10) FROM myseries`,err:`second argument to elapsed must be a duration, got *influxql.IntegerLiteral`},
{s:`SELECT elapsed(top(value)) FROM myseries where time < now() and time > now() - 1d group by time(1h)`,err:`invalid number of arguments for top, expected at least 2, got 1`},
{s:`SELECT elapsed(bottom(value)) FROM myseries where time < now() and time > now() - 1d group by time(1h)`,err:`invalid number of arguments for bottom, expected at least 2, got 1`},
{s:`SELECT elapsed(max()) FROM myseries where time < now() and time > now() - 1d group by time(1h)`,err:`invalid number of arguments for max, expected 1, got 0`},
{s:`SELECT elapsed(percentile(value)) FROM myseries where time < now() and time > now() - 1d group by time(1h)`,err:`invalid number of arguments for percentile, expected 2, got 1`},
{s:`SELECT elapsed(mean(value)) FROM myseries where time < now() and time > now() - 1d`,err:`elapsed aggregate requires a GROUP BY interval`},
{s:`SELECT moving_average(field1, 2), field1 FROM myseries`,err:`mixing aggregate and non-aggregate queries is not supported`},
{s:`SELECT moving_average(field1, 1), field1 FROM myseries`,err:`moving_average window must be greater than 1, got 1`},
{s:`SELECT moving_average(field1, 0), field1 FROM myseries`,err:`moving_average window must be greater than 1, got 0`},
{s:`SELECT moving_average(field1, -1), field1 FROM myseries`,err:`moving_average window must be greater than 1, got -1`},
{s:`SELECT moving_average(field1, 2.0), field1 FROM myseries`,err:`second argument for moving_average must be an integer, got *influxql.NumberLiteral`},
{s:`SELECT moving_average() from myseries`,err:`invalid number of arguments for moving_average, expected 2, got 0`},
{s:`SELECT moving_average(value) FROM myseries`,err:`invalid number of arguments for moving_average, expected 2, got 1`},
{s:`SELECT moving_average(value, 2) FROM myseries group by time(1h)`,err:`aggregate function required inside the call to moving_average`},
{s:`SELECT moving_average(top(value), 2) FROM myseries where time < now() and time > now() - 1d group by time(1h)`,err:`invalid number of arguments for top, expected at least 2, got 1`},
{s:`SELECT moving_average(bottom(value), 2) FROM myseries where time < now() and time > now() - 1d group by time(1h)`,err:`invalid number of arguments for bottom, expected at least 2, got 1`},
{s:`SELECT moving_average(max(), 2) FROM myseries where time < now() and time > now() - 1d group by time(1h)`,err:`invalid number of arguments for max, expected 1, got 0`},
{s:`SELECT moving_average(percentile(value), 2) FROM myseries where time < now() and time > now() - 1d group by time(1h)`,err:`invalid number of arguments for percentile, expected 2, got 1`},
{s:`SELECT moving_average(mean(value), 2) FROM myseries where time < now() and time > now() - 1d`,err:`moving_average aggregate requires a GROUP BY interval`},
{s:`SELECT cumulative_sum(field1), field1 FROM myseries`,err:`mixing aggregate and non-aggregate queries is not supported`},
{s:`SELECT cumulative_sum() from myseries`,err:`invalid number of arguments for cumulative_sum, expected 1, got 0`},
{s:`SELECT cumulative_sum(value) FROM myseries group by time(1h)`,err:`aggregate function required inside the call to cumulative_sum`},
{s:`SELECT cumulative_sum(top(value)) FROM myseries where time < now() and time > now() - 1d group by time(1h)`,err:`invalid number of arguments for top, expected at least 2, got 1`},
{s:`SELECT cumulative_sum(bottom(value)) FROM myseries where time < now() and time > now() - 1d group by time(1h)`,err:`invalid number of arguments for bottom, expected at least 2, got 1`},
{s:`SELECT cumulative_sum(max()) FROM myseries where time < now() and time > now() - 1d group by time(1h)`,err:`invalid number of arguments for max, expected 1, got 0`},
{s:`SELECT cumulative_sum(percentile(value)) FROM myseries where time < now() and time > now() - 1d group by time(1h)`,err:`invalid number of arguments for percentile, expected 2, got 1`},
{s:`SELECT cumulative_sum(mean(value)) FROM myseries where time < now() and time > now() - 1d`,err:`cumulative_sum aggregate requires a GROUP BY interval`},
{s:`SELECT integral() FROM myseries`,err:`invalid number of arguments for integral, expected at least 1 but no more than 2, got 0`},
{s:`SELECT integral(value, 10s, host) FROM myseries`,err:`invalid number of arguments for integral, expected at least 1 but no more than 2, got 3`},
{s:`SELECT integral(value, -10s) FROM myseries`,err:`duration argument must be positive, got -10s`},
{s:`SELECT integral(value, 10) FROM myseries`,err:`second argument must be a duration`},
{s:`SELECT holt_winters(value) FROM myseries where time < now() and time > now() - 1d`,err:`invalid number of arguments for holt_winters, expected 3, got 1`},
{s:`SELECT holt_winters(value, 10, 2) FROM myseries where time < now() and time > now() - 1d`,err:`must use aggregate function with holt_winters`},
{s:`SELECT holt_winters(min(value), 10, 2) FROM myseries where time < now() and time > now() - 1d`,err:`holt_winters aggregate requires a GROUP BY interval`},
{s:`SELECT holt_winters(min(value), 0, 2) FROM myseries where time < now() and time > now() - 1d GROUP BY time(1d)`,err:`second arg to holt_winters must be greater than 0, got 0`},
{s:`SELECT holt_winters(min(value), false, 2) FROM myseries where time < now() and time > now() - 1d GROUP BY time(1d)`,err:`expected integer argument as second arg in holt_winters`},
{s:`SELECT holt_winters(min(value), 10, 'string') FROM myseries where time < now() and time > now() - 1d GROUP BY time(1d)`,err:`expected integer argument as third arg in holt_winters`},
{s:`SELECT holt_winters(min(value), 10, -1) FROM myseries where time < now() and time > now() - 1d GROUP BY time(1d)`,err:`third arg to holt_winters cannot be negative, got -1`},
{s:`SELECT holt_winters_with_fit(value) FROM myseries where time < now() and time > now() - 1d`,err:`invalid number of arguments for holt_winters_with_fit, expected 3, got 1`},
{s:`SELECT holt_winters_with_fit(value, 10, 2) FROM myseries where time < now() and time > now() - 1d`,err:`must use aggregate function with holt_winters_with_fit`},
{s:`SELECT holt_winters_with_fit(min(value), 10, 2) FROM myseries where time < now() and time > now() - 1d`,err:`holt_winters_with_fit aggregate requires a GROUP BY interval`},
{s:`SELECT holt_winters_with_fit(min(value), 0, 2) FROM myseries where time < now() and time > now() - 1d GROUP BY time(1d)`,err:`second arg to holt_winters_with_fit must be greater than 0, got 0`},
{s:`SELECT holt_winters_with_fit(min(value), false, 2) FROM myseries where time < now() and time > now() - 1d GROUP BY time(1d)`,err:`expected integer argument as second arg in holt_winters_with_fit`},
{s:`SELECT holt_winters_with_fit(min(value), 10, 'string') FROM myseries where time < now() and time > now() - 1d GROUP BY time(1d)`,err:`expected integer argument as third arg in holt_winters_with_fit`},
{s:`SELECT holt_winters_with_fit(min(value), 10, -1) FROM myseries where time < now() and time > now() - 1d GROUP BY time(1d)`,err:`third arg to holt_winters_with_fit cannot be negative, got -1`},
{s:`SELECT mean(value) + value FROM cpu WHERE time < now() and time > now() - 1h GROUP BY time(10m)`,err:`mixing aggregate and non-aggregate queries is not supported`},
// TODO: Remove this restriction in the future: https://github.com/influxdata/influxdb/issues/5968
{s:`SELECT mean(cpu_total - cpu_idle) FROM cpu`,err:`expected field argument in mean()`},
{s:`SELECT derivative(mean(cpu_total - cpu_idle), 1s) FROM cpu WHERE time < now() AND time > now() - 1d GROUP BY time(1h)`,err:`expected field argument in mean()`},
// TODO: The error message will change when math is allowed inside an aggregate: https://github.com/influxdata/influxdb/pull/5990#issuecomment-195565870
{s:`SELECT count(foo + sum(bar)) FROM cpu`,err:`expected field argument in count()`},
{s:`SELECT (count(foo + sum(bar))) FROM cpu`,err:`expected field argument in count()`},
{s:`SELECT sum(value) + count(foo + sum(bar)) FROM cpu`,err:`expected field argument in count()`},
{s:`SELECT top(value, 2), max(value) FROM cpu`,err:`selector function top() cannot be combined with other functions`},
{s:`SELECT bottom(value, 2), max(value) FROM cpu`,err:`selector function bottom() cannot be combined with other functions`},
{s:`SELECT min(derivative) FROM (SELECT derivative(mean(value), 1h) FROM myseries) where time < now() and time > now() - 1d`,err:`derivative aggregate requires a GROUP BY interval`},
{s:`SELECT min(mean) FROM (SELECT mean(value) FROM myseries GROUP BY time)`,err:`time() is a function and expects at least one argument`},
{s:`SELECT value FROM myseries WHERE value OR time >= now() - 1m`,err:`invalid condition expression: value`},
{s:`SELECT value FROM myseries WHERE time >= now() - 1m OR value`,err:`invalid condition expression: value`},
{s:`SELECT value FROM (SELECT value FROM cpu ORDER BY time DESC) ORDER BY time ASC`,err:`subqueries must be ordered in the same direction as the query itself`},
