fix: Implement EXPLAIN, ORDER BY and default ordering (#6864)

* chore: Add more tests * chore: Fix default ordering; implement ORDER BY * feat: Add EXPLAIN support * chore: Add additional tests to validate GROUP BY expansion * chore: More test cases for TZ, and failing log scalar function
2023-02-08 08:18:52 +10:00 · 2023-02-08 08:18:52 +10:00 · a2945a77a4
parent d4e07eb6ac
commit a2945a77a4
37 changed files with 385 additions and 116 deletions
--- a/influxdb_iox/tests/query_tests2/cases.rs
+++ b/influxdb_iox/tests/query_tests2/cases.rs
@ -310,7 +310,7 @@ mod influxql {

        TestCase {
            input: "cases/in/issue_6112.influxql",
-            chunk_stage: ChunkStage::All,
+            chunk_stage: ChunkStage::Ingester,
        }
        .run()
        .await;
--- a/influxdb_iox/tests/query_tests2/cases/in/issue_6112.influxql
+++ b/influxdb_iox/tests/query_tests2/cases/in/issue_6112.influxql
@ -5,6 +5,7 @@
 -- Single measurement queries
 --

+-- Validates expected data is returned
 -- Projection wildcard, all tags and fields
 -- IOX_COMPARE: sorted
 SELECT * FROM m0;
@ -29,21 +30,6 @@ SELECT f64, tag0 FROM m0;
 -- IOX_COMPARE: sorted
 SELECT f64, tag0, time FROM m0;

-- Validate some math functions
-- IOX_COMPARE: sorted
-SELECT f64, floor(f64), ceil(f64) FROM m0;
-
-- Validate all scalar functions
-- -- IOX_COMPARE: sorted
-- TODO(sgc): log expects two arguments
-- TODO(sgc): asin and acos should cast NaN to NULL
-- SELECT f64, abs(f64), sin(f64), cos(f64), tan(f64),
--        asin(f64), acos(f64), atan(f64), atan2(f64, 1),
--        exp(f64), log(f64), ln(f64), log2(f64),
--        log10(f64), sqrt(f64), pow(f64, 2), floor(f64),
--        ceil(f64), round(f64)
-- FROM m0 LIMIT 1;
-
 -- arithmetic operators
 -- IOX_COMPARE: sorted
 SELECT f64, f64 * 2, i64, i64 + i64 FROM m0;
@ -121,3 +107,105 @@ SELECT tag1, f64 FROM m0 WHERE tag1 != '';
 -- TODO(sgc): Not working, as expected
 -- -- IOX_COMPARE: sorted
 -- SELECT tag1, f64 FROM m0 WHERE tag1 = '';
+
+--
+-- LIMIT and OFFSET clauses
+-- NOTE: these are working, but due to incorrect default ordering
+-- some tests fail
+--
+
+SELECT tag0, f64 FROM m0 LIMIT 1;
+
+SELECT tag0, f64 FROM m0 WHERE tag0 = 'val00' LIMIT 2 OFFSET 1;
+
+SELECT tag0, f64 FROM m0 LIMIT 1 OFFSET 1;
+
+-- OFFSET clause, no LIMIT clause
+-- TODO(sgc): Fails due to a bug in InfluxQL that utilises the following optimisation
+--  https://github.com/influxdata/influxdb/blob/dee8977d2c6598cb2d17e9334ea997c99853640a/tsdb/engine/tsm1/iterator.gen.go#L344-L347
+--  which breaks after returning the first point after the offset, because itr.opt.Limit == 0
+-- SELECT tag0, f64 FROM m0 OFFSET 1;
+
+--
+-- Sort ordering
+--
+
+-- No GROUP BY clause
+
+-- Default sort: expected output should default to ORDER BY TIME asc
+SELECT * FROM m0;
+
+-- Sort time in descending order
+SELECT * FROM m0 ORDER BY time DESC;
+
+--
+-- Scalar functions in projection
+--
+
+-- Validate all scalar functions with a float field
+SELECT
+    f64,
+    abs(f64 * -1),
+    sin(f64),
+    cos(f64),
+    tan(f64),
+    asin(1/f64),
+    acos(1/f64),
+    atan(f64),
+    atan2(f64, 2),
+    exp(f64),
+-- TODO(sgc): Dependent on https://github.com/apache/arrow-datafusion/issues/5206
+--    log(f64, 8),
+    ln(f64),
+    log2(f64),
+    log10(f64),
+    sqrt(f64),
+    pow(f64, 2),
+    floor(f64),
+    ceil(f64),
+    round(f64)
+FROM m0 LIMIT 1;
+
+-- Validate all scalar functions with an integer field
+SELECT
+    i64,
+    abs(i64 * -1),
+    sin(i64),
+    cos(i64),
+    tan(i64),
+-- TODO(sgc): Not coerced to float, so returns incorrect result
+--    asin(1/i64),
+    acos(1/i64),
+    atan(i64),
+    atan2(i64, 2),
+    exp(i64),
+-- TODO(sgc): Dependent on https://github.com/apache/arrow-datafusion/issues/5206
+--    log(i64, 8),
+    ln(i64),
+    log2(i64),
+    log10(i64),
+    sqrt(i64),
+    pow(i64, 2),
+    floor(i64),
+    ceil(i64),
+    round(i64)
+FROM m0 LIMIT 1;
+
+-- Deviation from InfluxQL is that NaNs are not coalesced to NULL
+-- The InfluxQL compatibility later will be responsible for this translation
+SELECT f64, asin(f64), acos(f64) FROM m0 LIMIT 1;
+
+-- INF support
+SELECT f64, pow(f64, pow(2, 10)) FROM m0 LIMIT 1;
+
+--
+-- TZ clause support
+--
+
+-- Interpret date/time (%Y-%M-%D %h:%m:%s) in timezone specified by TZ clause
+-- TODO(sgc): condition is correct, but `time` column is not display in local timezone
+--  as DataFusion does not support timestamp with timezone data types, and displaying
+--  the values in the local timezone
+
+---- SELECT f64 FROM m0 WHERE time = '2022-10-31 13:00:00' TZ('Australia/Hobart');
+---- SELECT f64 FROM m0 WHERE time = '2022-10-31T13:00:00Z' TZ('Australia/Hobart');
--- a/influxdb_iox/tests/query_tests2/cases/in/issue_6112.influxql.expected
+++ b/influxdb_iox/tests/query_tests2/cases/in/issue_6112.influxql.expected
@ -77,19 +77,6 @@
 | 19.2 | val00 | 2022-10-31T02:00:30Z |
 | 21.2 | val00 | 2022-10-31T02:00:10Z |
 +------+-------+----------------------+
-- InfluxQL: SELECT f64, floor(f64), ceil(f64) FROM m0;
-- Results After Sorting
-+----------------------+------+-------+------+
-| time                 | f64  | floor | ceil |
-+----------------------+------+-------+------+
-| 2022-10-31T02:00:00Z | 10.1 | 10    | 11   |
-| 2022-10-31T02:00:00Z | 10.4 | 10    | 11   |
-| 2022-10-31T02:00:00Z | 11.3 | 11    | 12   |
-| 2022-10-31T02:00:10Z | 18.9 | 18    | 19   |
-| 2022-10-31T02:00:10Z | 21.2 | 21    | 22   |
-| 2022-10-31T02:00:20Z | 11.2 | 11    | 12   |
-| 2022-10-31T02:00:30Z | 19.2 | 19    | 20   |
-+----------------------+------+-------+------+
 -- InfluxQL: SELECT f64, f64 * 2, i64, i64 + i64 FROM m0;
 -- Results After Sorting
 +----------------------+------+-------+-----+---------+
@ -227,4 +214,71 @@
 | time                 | tag1  | f64  |
 +----------------------+-------+------+
 | 2022-10-31T02:00:10Z | val10 | 18.9 |
-+----------------------+-------+------+
+----------------------+-------+------+
+-- InfluxQL: SELECT tag0, f64 FROM m0 LIMIT 1;
+----------------------+-------+------+
+| time                 | tag0  | f64  |
+----------------------+-------+------+
+| 2022-10-31T02:00:00Z | val00 | 10.1 |
+----------------------+-------+------+
+-- InfluxQL: SELECT tag0, f64 FROM m0 WHERE tag0 = 'val00' LIMIT 2 OFFSET 1;
+----------------------+-------+------+
+| time                 | tag0  | f64  |
+----------------------+-------+------+
+| 2022-10-31T02:00:10Z | val00 | 21.2 |
+| 2022-10-31T02:00:10Z | val00 | 18.9 |
+----------------------+-------+------+
+-- InfluxQL: SELECT tag0, f64 FROM m0 LIMIT 1 OFFSET 1;
+----------------------+-------+------+
+| time                 | tag0  | f64  |
+----------------------+-------+------+
+| 2022-10-31T02:00:00Z | val01 | 11.3 |
+----------------------+-------+------+
+-- InfluxQL: SELECT * FROM m0;
+----------------------+------+-----+-----+-------+-------+
+| time                 | f64  | i64 | str | tag0  | tag1  |
+----------------------+------+-----+-----+-------+-------+
+| 2022-10-31T02:00:00Z | 10.1 | 101 | hi  | val00 |       |
+| 2022-10-31T02:00:00Z | 11.3 | 211 | lo  | val01 |       |
+| 2022-10-31T02:00:00Z | 10.4 | 101 | lo  | val02 |       |
+| 2022-10-31T02:00:10Z | 21.2 | 211 | hi  | val00 |       |
+| 2022-10-31T02:00:10Z | 18.9 | 211 | lo  | val00 | val10 |
+| 2022-10-31T02:00:20Z | 11.2 | 191 | lo  | val00 |       |
+| 2022-10-31T02:00:30Z | 19.2 | 392 | lo  | val00 |       |
+----------------------+------+-----+-----+-------+-------+
+-- InfluxQL: SELECT * FROM m0 ORDER BY time DESC;
+----------------------+------+-----+-----+-------+-------+
+| time                 | f64  | i64 | str | tag0  | tag1  |
+----------------------+------+-----+-----+-------+-------+
+| 2022-10-31T02:00:30Z | 19.2 | 392 | lo  | val00 |       |
+| 2022-10-31T02:00:20Z | 11.2 | 191 | lo  | val00 |       |
+| 2022-10-31T02:00:10Z | 21.2 | 211 | hi  | val00 |       |
+| 2022-10-31T02:00:10Z | 18.9 | 211 | lo  | val00 | val10 |
+| 2022-10-31T02:00:00Z | 10.1 | 101 | hi  | val00 |       |
+| 2022-10-31T02:00:00Z | 11.3 | 211 | lo  | val01 |       |
+| 2022-10-31T02:00:00Z | 10.4 | 101 | lo  | val02 |       |
+----------------------+------+-----+-----+-------+-------+
+-- InfluxQL: SELECT f64, abs(f64 * -1), sin(f64), cos(f64), tan(f64), asin(1/f64), acos(1/f64), atan(f64), atan2(f64, 2), exp(f64), ln(f64), log2(f64), log10(f64), sqrt(f64), pow(f64, 2), floor(f64), ceil(f64), round(f64) FROM m0 LIMIT 1;
+----------------------+------+------+---------------------+---------------------+--------------------+--------------------+-------------------+------------------+--------------------+-------------------+-------------------+--------------------+--------------------+--------------------+--------------------+-------+------+-------+
+| time                 | f64  | abs  | sin                 | cos                 | tan                | asin               | acos              | atan             | atan2              | exp               | ln                | log2               | log10              | sqrt               | pow                | floor | ceil | round |
+----------------------+------+------+---------------------+---------------------+--------------------+--------------------+-------------------+------------------+--------------------+-------------------+-------------------+--------------------+--------------------+--------------------+--------------------+-------+------+-------+
+| 2022-10-31T02:00:00Z | 10.1 | 10.1 | -0.6250706488928821 | -0.7805681801691837 | 0.8007893029375109 | 0.0991723838059207 | 1.471623942988976 | 1.47210806614649 | 1.3753055265462157 | 24343.00942440838 | 2.312535423847214 | 3.3362833878644325 | 1.0043213737826426 | 3.1780497164141406 | 102.00999999999999 | 10    | 11   | 10    |
+----------------------+------+------+---------------------+---------------------+--------------------+--------------------+-------------------+------------------+--------------------+-------------------+-------------------+--------------------+--------------------+--------------------+--------------------+-------+------+-------+
+-- InfluxQL: SELECT i64, abs(i64 * -1), sin(i64), cos(i64), tan(i64), acos(1/i64), atan(i64), atan2(i64, 2), exp(i64), ln(i64), log2(i64), log10(i64), sqrt(i64), pow(i64, 2), floor(i64), ceil(i64), round(i64) FROM m0 LIMIT 1;
+----------------------+-----+-----+---------------------+--------------------+--------------------+--------------------+-------------------+-----------+----------------------------------------------+------------------+-------------------+--------------------+-------------------+-------+-------+------+-------+
+| time                 | i64 | abs | sin                 | cos                | tan                | acos               | atan              | atan2     | exp                                          | ln               | log2              | log10              | sqrt              | pow   | floor | ceil | round |
+----------------------+-----+-----+---------------------+--------------------+--------------------+--------------------+-------------------+-----------+----------------------------------------------+------------------+-------------------+--------------------+-------------------+-------+-------+------+-------+
+| 2022-10-31T02:00:00Z | 101 | 101 | 0.45202578717835057 | 0.8920048697881602 | 0.5067526002248183 | 1.5707963267948966 | 1.560895660206908 | 1.5509969 | 73070599793680670000000000000000000000000000 | 4.61512051684126 | 6.658211482751795 | 2.0043213737826426 | 10.04987562112089 | 10201 | 101   | 101  | 101   |
+----------------------+-----+-----+---------------------+--------------------+--------------------+--------------------+-------------------+-----------+----------------------------------------------+------------------+-------------------+--------------------+-------------------+-------+-------+------+-------+
+-- InfluxQL: SELECT f64, asin(f64), acos(f64) FROM m0 LIMIT 1;
+----------------------+------+------+------+
+| time                 | f64  | asin | acos |
+----------------------+------+------+------+
+| 2022-10-31T02:00:00Z | 10.1 | NaN  | NaN  |
+----------------------+------+------+------+
+-- InfluxQL: SELECT f64, pow(f64, pow(2, 10)) FROM m0 LIMIT 1;
+----------------------+------+-----+
+| time                 | f64  | pow |
+----------------------+------+-----+
+| 2022-10-31T02:00:00Z | 10.1 | inf |
+----------------------+------+-----+
--- a/iox_query/src/plan/influxql/planner.rs
+++ b/iox_query/src/plan/influxql/planner.rs
@ -3,16 +3,20 @@ use crate::plan::influxql::rewriter::rewrite_statement;
 use crate::plan::influxql::util::binary_operator_to_df_operator;
 use crate::{DataFusionError, IOxSessionContext, QueryNamespace};
 use arrow::datatypes::DataType;
-use datafusion::common::{DFSchema, DFSchemaRef, Result, ScalarValue};
+use datafusion::common::{DFSchema, DFSchemaRef, Result, ScalarValue, ToDFSchema};
 use datafusion::datasource::provider_as_source;
+use datafusion::logical_expr::expr::Sort;
 use datafusion::logical_expr::expr_rewriter::{normalize_col, ExprRewritable, ExprRewriter};
 use datafusion::logical_expr::logical_plan::builder::project;
+use datafusion::logical_expr::logical_plan::Analyze;
 use datafusion::logical_expr::{
-    lit, BinaryExpr, BuiltinScalarFunction, Expr, ExprSchemable, LogicalPlan, LogicalPlanBuilder,
-    Operator,
+    lit, BinaryExpr, BuiltinScalarFunction, Explain, Expr, ExprSchemable, LogicalPlan,
+    LogicalPlanBuilder, Operator, PlanType, ToStringifiedPlan,
 };
 use datafusion::prelude::Column;
 use datafusion::sql::TableReference;
+use influxdb_influxql_parser::common::OrderByClause;
+use influxdb_influxql_parser::explain::{ExplainOption, ExplainStatement};
 use influxdb_influxql_parser::expression::{
    BinaryOperator, ConditionalExpression, ConditionalOperator, VarRefDataType,
 };
@ -29,6 +33,7 @@ use once_cell::sync::Lazy;
 use query_functions::clean_non_meta_escapes;
 use schema::{InfluxColumnType, InfluxFieldType, Schema};
 use std::collections::HashSet;
+use std::iter;
 use std::ops::Deref;
 use std::str::FromStr;
 use std::sync::Arc;
@ -70,11 +75,8 @@ impl<'a> InfluxQLToLogicalPlan<'a> {
            Statement::DropMeasurement(_) => {
                Err(DataFusionError::NotImplemented("DROP MEASUREMENT".into()))
            }
-            Statement::Explain(_) => Err(DataFusionError::NotImplemented("EXPLAIN".into())),
-            Statement::Select(select) => {
-                let select = rewrite_statement(self.database.as_meta(), &select)?;
-                self.select_statement_to_plan(select).await
-            }
+            Statement::Explain(explain) => self.explain_statement_to_plan(*explain).await,
+            Statement::Select(select) => self.select_statement_to_plan(*select).await,
            Statement::ShowDatabases(_) => {
                Err(DataFusionError::NotImplemented("SHOW DATABASES".into()))
            }
@ -96,8 +98,41 @@ impl<'a> InfluxQLToLogicalPlan<'a> {
        }
    }

+    async fn explain_statement_to_plan(&self, explain: ExplainStatement) -> Result<LogicalPlan> {
+        let plan = self.select_statement_to_plan(*explain.select).await?;
+        let plan = Arc::new(plan);
+        let schema = LogicalPlan::explain_schema();
+        let schema = schema.to_dfschema_ref()?;
+
+        let (analyze, verbose) = match explain.options {
+            Some(ExplainOption::AnalyzeVerbose) => (true, true),
+            Some(ExplainOption::Analyze) => (true, false),
+            Some(ExplainOption::Verbose) => (false, true),
+            None => (false, false),
+        };
+
+        if analyze {
+            Ok(LogicalPlan::Analyze(Analyze {
+                verbose,
+                input: plan,
+                schema,
+            }))
+        } else {
+            let stringified_plans = vec![plan.to_stringified(PlanType::InitialLogicalPlan)];
+            Ok(LogicalPlan::Explain(Explain {
+                verbose,
+                plan,
+                stringified_plans,
+                schema,
+                logical_optimization_succeeded: false,
+            }))
+        }
+    }
+
    /// Create a [`LogicalPlan`] from the specified InfluxQL `SELECT` statement.
    async fn select_statement_to_plan(&self, select: SelectStatement) -> Result<LogicalPlan> {
+        let select = rewrite_statement(self.database.as_meta(), &select)?;
+
        // Process FROM clause
        let plans = self.plan_from_tables(select.from).await?;

@ -114,6 +149,27 @@ impl<'a> InfluxQLToLogicalPlan<'a> {
        let tz = select.timezone.map(|tz| *tz);
        let plan = self.plan_where_clause(select.condition, plan, tz)?;

+        let plan = if select.group_by.is_none() {
+            LogicalPlanBuilder::from(plan)
+                .sort(iter::once(Expr::Sort(Sort {
+                    expr: Box::new(Expr::Column(Column {
+                        relation: None,
+                        name: "time".to_string(),
+                    })),
+                    asc: match select.order_by {
+                        // Default behaviour is to sort by time in ascending order if there is no ORDER BY
+                        None | Some(OrderByClause::Ascending) => true,
+                        Some(OrderByClause::Descending) => false,
+                    },
+                    nulls_first: false,
+                })))?
+                .build()
+        } else {
+            Err(DataFusionError::NotImplemented(
+                "GROUP BY not supported".into(),
+            ))
+        }?;
+
        // Process and validate the field expressions in the SELECT projection list
        let select_exprs = self.field_list_to_exprs(&plan, select.fields)?;

@ -647,7 +703,6 @@ mod test {
        assert_snapshot!(plan("CREATE DATABASE foo").await);
        assert_snapshot!(plan("DELETE FROM foo").await);
        assert_snapshot!(plan("DROP MEASUREMENT foo").await);
-        assert_snapshot!(plan("EXPLAIN SELECT bar FROM foo").await);
        assert_snapshot!(plan("SHOW DATABASES").await);
        assert_snapshot!(plan("SHOW MEASUREMENTS").await);
        assert_snapshot!(plan("SHOW RETENTION POLICIES").await);
@ -702,6 +757,14 @@ mod test {
                plan("SELECT foo, f64_field FROM data where non_existent !~ /f/").await
            );
        }
+
+        #[tokio::test]
+        async fn test_explain() {
+            assert_snapshot!(plan("EXPLAIN SELECT foo, f64_field FROM data").await);
+            assert_snapshot!(plan("EXPLAIN VERBOSE SELECT foo, f64_field FROM data").await);
+            assert_snapshot!(plan("EXPLAIN ANALYZE SELECT foo, f64_field FROM data").await);
+            assert_snapshot!(plan("EXPLAIN ANALYZE VERBOSE SELECT foo, f64_field FROM data").await);
+        }
    }

    /// Tests to validate InfluxQL `SELECT` statements that project columns without specifying
--- a/iox_query/src/plan/influxql/rewriter.rs
+++ b/iox_query/src/plan/influxql/rewriter.rs
@ -625,6 +625,22 @@ mod test {
            "SELECT usage_idle::float AS usage_idle FROM cpu GROUP BY host, region"
        );

+        // Does not include tags in projection when expanded in GROUP BY
+        let stmt = parse_select("SELECT * FROM cpu GROUP BY *");
+        let stmt = rewrite_statement(&namespace, &stmt).unwrap();
+        assert_eq!(
+            stmt.to_string(),
+            "SELECT usage_idle::float AS usage_idle, usage_system::float AS usage_system, usage_user::float AS usage_user FROM cpu GROUP BY host, region"
+        );
+
+        // Does include explicitly listed tags in projection
+        let stmt = parse_select("SELECT host, * FROM cpu GROUP BY *");
+        let stmt = rewrite_statement(&namespace, &stmt).unwrap();
+        assert_eq!(
+            stmt.to_string(),
+            "SELECT host::tag AS host, usage_idle::float AS usage_idle, usage_system::float AS usage_system, usage_user::float AS usage_user FROM cpu GROUP BY host, region"
+        );
+
        // Fallible

        // Invalid regex
--- a/iox_query/src/plan/influxql/snapshots/iox_queryplaninfluxqlplannertestselectexplain-2.snap
+++ b/iox_query/src/plan/influxql/snapshots/iox_queryplaninfluxqlplannertestselectexplain-2.snap
@ -0,0 +1,8 @@
+---
+source: iox_query/src/plan/influxql/planner.rs
+expression: "plan(\"EXPLAIN VERBOSE SELECT foo, f64_field FROM data\").await"
+---
+Explain [plan_type:Utf8, plan:Utf8]
+  Projection: data.time, data.foo AS foo, data.f64_field AS f64_field [time:Timestamp(Nanosecond, None), foo:Dictionary(Int32, Utf8);N, f64_field:Float64;N]
+    Sort: data.time ASC NULLS LAST [TIME:Boolean;N, bar:Dictionary(Int32, Utf8);N, bool_field:Boolean;N, f64_field:Float64;N, foo:Dictionary(Int32, Utf8);N, i64_field:Int64;N, mixedCase:Float64;N, str_field:Utf8;N, time:Timestamp(Nanosecond, None), with space:Float64;N]
+      TableScan: data [TIME:Boolean;N, bar:Dictionary(Int32, Utf8);N, bool_field:Boolean;N, f64_field:Float64;N, foo:Dictionary(Int32, Utf8);N, i64_field:Int64;N, mixedCase:Float64;N, str_field:Utf8;N, time:Timestamp(Nanosecond, None), with space:Float64;N]
--- a/iox_query/src/plan/influxql/snapshots/iox_queryplaninfluxqlplannertestselectexplain-3.snap
+++ b/iox_query/src/plan/influxql/snapshots/iox_queryplaninfluxqlplannertestselectexplain-3.snap
@ -0,0 +1,8 @@
+---
+source: iox_query/src/plan/influxql/planner.rs
+expression: "plan(\"EXPLAIN ANALYZE SELECT foo, f64_field FROM data\").await"
+---
+Analyze [plan_type:Utf8, plan:Utf8]
+  Projection: data.time, data.foo AS foo, data.f64_field AS f64_field [time:Timestamp(Nanosecond, None), foo:Dictionary(Int32, Utf8);N, f64_field:Float64;N]
+    Sort: data.time ASC NULLS LAST [TIME:Boolean;N, bar:Dictionary(Int32, Utf8);N, bool_field:Boolean;N, f64_field:Float64;N, foo:Dictionary(Int32, Utf8);N, i64_field:Int64;N, mixedCase:Float64;N, str_field:Utf8;N, time:Timestamp(Nanosecond, None), with space:Float64;N]
+      TableScan: data [TIME:Boolean;N, bar:Dictionary(Int32, Utf8);N, bool_field:Boolean;N, f64_field:Float64;N, foo:Dictionary(Int32, Utf8);N, i64_field:Int64;N, mixedCase:Float64;N, str_field:Utf8;N, time:Timestamp(Nanosecond, None), with space:Float64;N]
--- a/iox_query/src/plan/influxql/snapshots/iox_queryplaninfluxqlplannertestselectexplain-4.snap
+++ b/iox_query/src/plan/influxql/snapshots/iox_queryplaninfluxqlplannertestselectexplain-4.snap
@ -0,0 +1,8 @@
+---
+source: iox_query/src/plan/influxql/planner.rs
+expression: "plan(\"EXPLAIN ANALYZE VERBOSE SELECT foo, f64_field FROM data\").await"
+---
+Analyze [plan_type:Utf8, plan:Utf8]
+  Projection: data.time, data.foo AS foo, data.f64_field AS f64_field [time:Timestamp(Nanosecond, None), foo:Dictionary(Int32, Utf8);N, f64_field:Float64;N]
+    Sort: data.time ASC NULLS LAST [TIME:Boolean;N, bar:Dictionary(Int32, Utf8);N, bool_field:Boolean;N, f64_field:Float64;N, foo:Dictionary(Int32, Utf8);N, i64_field:Int64;N, mixedCase:Float64;N, str_field:Utf8;N, time:Timestamp(Nanosecond, None), with space:Float64;N]
+      TableScan: data [TIME:Boolean;N, bar:Dictionary(Int32, Utf8);N, bool_field:Boolean;N, f64_field:Float64;N, foo:Dictionary(Int32, Utf8);N, i64_field:Int64;N, mixedCase:Float64;N, str_field:Utf8;N, time:Timestamp(Nanosecond, None), with space:Float64;N]
--- a/iox_query/src/plan/influxql/snapshots/iox_queryplaninfluxqlplannertestselectexplain.snap
+++ b/iox_query/src/plan/influxql/snapshots/iox_queryplaninfluxqlplannertestselectexplain.snap
@ -0,0 +1,8 @@
+---
+source: iox_query/src/plan/influxql/planner.rs
+expression: "plan(\"EXPLAIN SELECT foo, f64_field FROM data\").await"
+---
+Explain [plan_type:Utf8, plan:Utf8]
+  Projection: data.time, data.foo AS foo, data.f64_field AS f64_field [time:Timestamp(Nanosecond, None), foo:Dictionary(Int32, Utf8);N, f64_field:Float64;N]
+    Sort: data.time ASC NULLS LAST [TIME:Boolean;N, bar:Dictionary(Int32, Utf8);N, bool_field:Boolean;N, f64_field:Float64;N, foo:Dictionary(Int32, Utf8);N, i64_field:Int64;N, mixedCase:Float64;N, str_field:Utf8;N, time:Timestamp(Nanosecond, None), with space:Float64;N]
+      TableScan: data [TIME:Boolean;N, bar:Dictionary(Int32, Utf8);N, bool_field:Boolean;N, f64_field:Float64;N, foo:Dictionary(Int32, Utf8);N, i64_field:Int64;N, mixedCase:Float64;N, str_field:Utf8;N, time:Timestamp(Nanosecond, None), with space:Float64;N]
--- a/iox_query/src/plan/influxql/snapshots/iox_queryplaninfluxqlplannertestselecttime_range_in_where-10.snap
+++ b/iox_query/src/plan/influxql/snapshots/iox_queryplaninfluxqlplannertestselecttime_range_in_where-10.snap
@ -3,5 +3,6 @@ source: iox_query/src/plan/influxql/planner.rs
 expression: "plan(\"SELECT foo, f64_field FROM data where non_existent !~ /f/\").await"
 ---
 Projection: data.time, data.foo AS foo, data.f64_field AS f64_field [time:Timestamp(Nanosecond, None), foo:Dictionary(Int32, Utf8);N, f64_field:Float64;N]
-  Filter: Boolean(false) [TIME:Boolean;N, bar:Dictionary(Int32, Utf8);N, bool_field:Boolean;N, f64_field:Float64;N, foo:Dictionary(Int32, Utf8);N, i64_field:Int64;N, mixedCase:Float64;N, str_field:Utf8;N, time:Timestamp(Nanosecond, None), with space:Float64;N]
-    TableScan: data [TIME:Boolean;N, bar:Dictionary(Int32, Utf8);N, bool_field:Boolean;N, f64_field:Float64;N, foo:Dictionary(Int32, Utf8);N, i64_field:Int64;N, mixedCase:Float64;N, str_field:Utf8;N, time:Timestamp(Nanosecond, None), with space:Float64;N]
+  Sort: data.time ASC NULLS LAST [TIME:Boolean;N, bar:Dictionary(Int32, Utf8);N, bool_field:Boolean;N, f64_field:Float64;N, foo:Dictionary(Int32, Utf8);N, i64_field:Int64;N, mixedCase:Float64;N, str_field:Utf8;N, time:Timestamp(Nanosecond, None), with space:Float64;N]
+    Filter: Boolean(false) [TIME:Boolean;N, bar:Dictionary(Int32, Utf8);N, bool_field:Boolean;N, f64_field:Float64;N, foo:Dictionary(Int32, Utf8);N, i64_field:Int64;N, mixedCase:Float64;N, str_field:Utf8;N, time:Timestamp(Nanosecond, None), with space:Float64;N]
+      TableScan: data [TIME:Boolean;N, bar:Dictionary(Int32, Utf8);N, bool_field:Boolean;N, f64_field:Float64;N, foo:Dictionary(Int32, Utf8);N, i64_field:Int64;N, mixedCase:Float64;N, str_field:Utf8;N, time:Timestamp(Nanosecond, None), with space:Float64;N]
--- a/iox_query/src/plan/influxql/snapshots/iox_queryplaninfluxqlplannertestselecttime_range_in_where-2.snap
+++ b/iox_query/src/plan/influxql/snapshots/iox_queryplaninfluxqlplannertestselecttime_range_in_where-2.snap
@ -3,5 +3,6 @@ source: iox_query/src/plan/influxql/planner.rs
 expression: "plan(\"SELECT foo, f64_field FROM data where time > '2004-04-09T02:33:45Z'\").await"
 ---
 Projection: data.time, data.foo AS foo, data.f64_field AS f64_field [time:Timestamp(Nanosecond, None), foo:Dictionary(Int32, Utf8);N, f64_field:Float64;N]
-  Filter: data.time > TimestampNanosecond(1081478025000000000, None) [TIME:Boolean;N, bar:Dictionary(Int32, Utf8);N, bool_field:Boolean;N, f64_field:Float64;N, foo:Dictionary(Int32, Utf8);N, i64_field:Int64;N, mixedCase:Float64;N, str_field:Utf8;N, time:Timestamp(Nanosecond, None), with space:Float64;N]
-    TableScan: data [TIME:Boolean;N, bar:Dictionary(Int32, Utf8);N, bool_field:Boolean;N, f64_field:Float64;N, foo:Dictionary(Int32, Utf8);N, i64_field:Int64;N, mixedCase:Float64;N, str_field:Utf8;N, time:Timestamp(Nanosecond, None), with space:Float64;N]
+  Sort: data.time ASC NULLS LAST [TIME:Boolean;N, bar:Dictionary(Int32, Utf8);N, bool_field:Boolean;N, f64_field:Float64;N, foo:Dictionary(Int32, Utf8);N, i64_field:Int64;N, mixedCase:Float64;N, str_field:Utf8;N, time:Timestamp(Nanosecond, None), with space:Float64;N]
+    Filter: data.time > TimestampNanosecond(1081478025000000000, None) [TIME:Boolean;N, bar:Dictionary(Int32, Utf8);N, bool_field:Boolean;N, f64_field:Float64;N, foo:Dictionary(Int32, Utf8);N, i64_field:Int64;N, mixedCase:Float64;N, str_field:Utf8;N, time:Timestamp(Nanosecond, None), with space:Float64;N]
+      TableScan: data [TIME:Boolean;N, bar:Dictionary(Int32, Utf8);N, bool_field:Boolean;N, f64_field:Float64;N, foo:Dictionary(Int32, Utf8);N, i64_field:Int64;N, mixedCase:Float64;N, str_field:Utf8;N, time:Timestamp(Nanosecond, None), with space:Float64;N]
--- a/iox_query/src/plan/influxql/snapshots/iox_queryplaninfluxqlplannertestselecttime_range_in_where-4.snap
+++ b/iox_query/src/plan/influxql/snapshots/iox_queryplaninfluxqlplannertestselecttime_range_in_where-4.snap
@ -3,5 +3,6 @@ source: iox_query/src/plan/influxql/planner.rs
 expression: "plan(\"SELECT foo, f64_field FROM data where  now() - 10s < time\").await"
 ---
 Projection: data.time, data.foo AS foo, data.f64_field AS f64_field [time:Timestamp(Nanosecond, None), foo:Dictionary(Int32, Utf8);N, f64_field:Float64;N]
-  Filter: now() - IntervalMonthDayNano("10000000000") < data.time [TIME:Boolean;N, bar:Dictionary(Int32, Utf8);N, bool_field:Boolean;N, f64_field:Float64;N, foo:Dictionary(Int32, Utf8);N, i64_field:Int64;N, mixedCase:Float64;N, str_field:Utf8;N, time:Timestamp(Nanosecond, None), with space:Float64;N]
-    TableScan: data [TIME:Boolean;N, bar:Dictionary(Int32, Utf8);N, bool_field:Boolean;N, f64_field:Float64;N, foo:Dictionary(Int32, Utf8);N, i64_field:Int64;N, mixedCase:Float64;N, str_field:Utf8;N, time:Timestamp(Nanosecond, None), with space:Float64;N]
+  Sort: data.time ASC NULLS LAST [TIME:Boolean;N, bar:Dictionary(Int32, Utf8);N, bool_field:Boolean;N, f64_field:Float64;N, foo:Dictionary(Int32, Utf8);N, i64_field:Int64;N, mixedCase:Float64;N, str_field:Utf8;N, time:Timestamp(Nanosecond, None), with space:Float64;N]
+    Filter: now() - IntervalMonthDayNano("10000000000") < data.time [TIME:Boolean;N, bar:Dictionary(Int32, Utf8);N, bool_field:Boolean;N, f64_field:Float64;N, foo:Dictionary(Int32, Utf8);N, i64_field:Int64;N, mixedCase:Float64;N, str_field:Utf8;N, time:Timestamp(Nanosecond, None), with space:Float64;N]
+      TableScan: data [TIME:Boolean;N, bar:Dictionary(Int32, Utf8);N, bool_field:Boolean;N, f64_field:Float64;N, foo:Dictionary(Int32, Utf8);N, i64_field:Int64;N, mixedCase:Float64;N, str_field:Utf8;N, time:Timestamp(Nanosecond, None), with space:Float64;N]
--- a/iox_query/src/plan/influxql/snapshots/iox_queryplaninfluxqlplannertestselecttime_range_in_where-5.snap
+++ b/iox_query/src/plan/influxql/snapshots/iox_queryplaninfluxqlplannertestselecttime_range_in_where-5.snap
@ -3,5 +3,6 @@ source: iox_query/src/plan/influxql/planner.rs
 expression: "plan(\"SELECT foo, f64_field FROM data where foo =~ /f/\").await"
 ---
 Projection: data.time, data.foo AS foo, data.f64_field AS f64_field [time:Timestamp(Nanosecond, None), foo:Dictionary(Int32, Utf8);N, f64_field:Float64;N]
-  Filter: CAST(data.foo AS Utf8) ~ Utf8("f") [TIME:Boolean;N, bar:Dictionary(Int32, Utf8);N, bool_field:Boolean;N, f64_field:Float64;N, foo:Dictionary(Int32, Utf8);N, i64_field:Int64;N, mixedCase:Float64;N, str_field:Utf8;N, time:Timestamp(Nanosecond, None), with space:Float64;N]
-    TableScan: data [TIME:Boolean;N, bar:Dictionary(Int32, Utf8);N, bool_field:Boolean;N, f64_field:Float64;N, foo:Dictionary(Int32, Utf8);N, i64_field:Int64;N, mixedCase:Float64;N, str_field:Utf8;N, time:Timestamp(Nanosecond, None), with space:Float64;N]
+  Sort: data.time ASC NULLS LAST [TIME:Boolean;N, bar:Dictionary(Int32, Utf8);N, bool_field:Boolean;N, f64_field:Float64;N, foo:Dictionary(Int32, Utf8);N, i64_field:Int64;N, mixedCase:Float64;N, str_field:Utf8;N, time:Timestamp(Nanosecond, None), with space:Float64;N]
+    Filter: CAST(data.foo AS Utf8) ~ Utf8("f") [TIME:Boolean;N, bar:Dictionary(Int32, Utf8);N, bool_field:Boolean;N, f64_field:Float64;N, foo:Dictionary(Int32, Utf8);N, i64_field:Int64;N, mixedCase:Float64;N, str_field:Utf8;N, time:Timestamp(Nanosecond, None), with space:Float64;N]
+      TableScan: data [TIME:Boolean;N, bar:Dictionary(Int32, Utf8);N, bool_field:Boolean;N, f64_field:Float64;N, foo:Dictionary(Int32, Utf8);N, i64_field:Int64;N, mixedCase:Float64;N, str_field:Utf8;N, time:Timestamp(Nanosecond, None), with space:Float64;N]
--- a/iox_query/src/plan/influxql/snapshots/iox_queryplaninfluxqlplannertestselecttime_range_in_where-6.snap
+++ b/iox_query/src/plan/influxql/snapshots/iox_queryplaninfluxqlplannertestselecttime_range_in_where-6.snap
@ -3,5 +3,6 @@ source: iox_query/src/plan/influxql/planner.rs
 expression: "plan(\"SELECT foo, f64_field FROM data where f64_field =~ /f/\").await"
 ---
 Projection: data.time, data.foo AS foo, data.f64_field AS f64_field [time:Timestamp(Nanosecond, None), foo:Dictionary(Int32, Utf8);N, f64_field:Float64;N]
-  Filter: Boolean(false) [TIME:Boolean;N, bar:Dictionary(Int32, Utf8);N, bool_field:Boolean;N, f64_field:Float64;N, foo:Dictionary(Int32, Utf8);N, i64_field:Int64;N, mixedCase:Float64;N, str_field:Utf8;N, time:Timestamp(Nanosecond, None), with space:Float64;N]
-    TableScan: data [TIME:Boolean;N, bar:Dictionary(Int32, Utf8);N, bool_field:Boolean;N, f64_field:Float64;N, foo:Dictionary(Int32, Utf8);N, i64_field:Int64;N, mixedCase:Float64;N, str_field:Utf8;N, time:Timestamp(Nanosecond, None), with space:Float64;N]
+  Sort: data.time ASC NULLS LAST [TIME:Boolean;N, bar:Dictionary(Int32, Utf8);N, bool_field:Boolean;N, f64_field:Float64;N, foo:Dictionary(Int32, Utf8);N, i64_field:Int64;N, mixedCase:Float64;N, str_field:Utf8;N, time:Timestamp(Nanosecond, None), with space:Float64;N]
+    Filter: Boolean(false) [TIME:Boolean;N, bar:Dictionary(Int32, Utf8);N, bool_field:Boolean;N, f64_field:Float64;N, foo:Dictionary(Int32, Utf8);N, i64_field:Int64;N, mixedCase:Float64;N, str_field:Utf8;N, time:Timestamp(Nanosecond, None), with space:Float64;N]
+      TableScan: data [TIME:Boolean;N, bar:Dictionary(Int32, Utf8);N, bool_field:Boolean;N, f64_field:Float64;N, foo:Dictionary(Int32, Utf8);N, i64_field:Int64;N, mixedCase:Float64;N, str_field:Utf8;N, time:Timestamp(Nanosecond, None), with space:Float64;N]
--- a/iox_query/src/plan/influxql/snapshots/iox_queryplaninfluxqlplannertestselecttime_range_in_where-7.snap
+++ b/iox_query/src/plan/influxql/snapshots/iox_queryplaninfluxqlplannertestselecttime_range_in_where-7.snap
@ -3,5 +3,6 @@ source: iox_query/src/plan/influxql/planner.rs
 expression: "plan(\"SELECT foo, f64_field FROM data where non_existent =~ /f/\").await"
 ---
 Projection: data.time, data.foo AS foo, data.f64_field AS f64_field [time:Timestamp(Nanosecond, None), foo:Dictionary(Int32, Utf8);N, f64_field:Float64;N]
-  Filter: Boolean(false) [TIME:Boolean;N, bar:Dictionary(Int32, Utf8);N, bool_field:Boolean;N, f64_field:Float64;N, foo:Dictionary(Int32, Utf8);N, i64_field:Int64;N, mixedCase:Float64;N, str_field:Utf8;N, time:Timestamp(Nanosecond, None), with space:Float64;N]
-    TableScan: data [TIME:Boolean;N, bar:Dictionary(Int32, Utf8);N, bool_field:Boolean;N, f64_field:Float64;N, foo:Dictionary(Int32, Utf8);N, i64_field:Int64;N, mixedCase:Float64;N, str_field:Utf8;N, time:Timestamp(Nanosecond, None), with space:Float64;N]
+  Sort: data.time ASC NULLS LAST [TIME:Boolean;N, bar:Dictionary(Int32, Utf8);N, bool_field:Boolean;N, f64_field:Float64;N, foo:Dictionary(Int32, Utf8);N, i64_field:Int64;N, mixedCase:Float64;N, str_field:Utf8;N, time:Timestamp(Nanosecond, None), with space:Float64;N]
+    Filter: Boolean(false) [TIME:Boolean;N, bar:Dictionary(Int32, Utf8);N, bool_field:Boolean;N, f64_field:Float64;N, foo:Dictionary(Int32, Utf8);N, i64_field:Int64;N, mixedCase:Float64;N, str_field:Utf8;N, time:Timestamp(Nanosecond, None), with space:Float64;N]
+      TableScan: data [TIME:Boolean;N, bar:Dictionary(Int32, Utf8);N, bool_field:Boolean;N, f64_field:Float64;N, foo:Dictionary(Int32, Utf8);N, i64_field:Int64;N, mixedCase:Float64;N, str_field:Utf8;N, time:Timestamp(Nanosecond, None), with space:Float64;N]
--- a/iox_query/src/plan/influxql/snapshots/iox_queryplaninfluxqlplannertestselecttime_range_in_where-8.snap
+++ b/iox_query/src/plan/influxql/snapshots/iox_queryplaninfluxqlplannertestselecttime_range_in_where-8.snap
@ -3,5 +3,6 @@ source: iox_query/src/plan/influxql/planner.rs
 expression: "plan(\"SELECT foo, f64_field FROM data where foo !~ /f/\").await"
 ---
 Projection: data.time, data.foo AS foo, data.f64_field AS f64_field [time:Timestamp(Nanosecond, None), foo:Dictionary(Int32, Utf8);N, f64_field:Float64;N]
-  Filter: CAST(data.foo AS Utf8) !~ Utf8("f") [TIME:Boolean;N, bar:Dictionary(Int32, Utf8);N, bool_field:Boolean;N, f64_field:Float64;N, foo:Dictionary(Int32, Utf8);N, i64_field:Int64;N, mixedCase:Float64;N, str_field:Utf8;N, time:Timestamp(Nanosecond, None), with space:Float64;N]
-    TableScan: data [TIME:Boolean;N, bar:Dictionary(Int32, Utf8);N, bool_field:Boolean;N, f64_field:Float64;N, foo:Dictionary(Int32, Utf8);N, i64_field:Int64;N, mixedCase:Float64;N, str_field:Utf8;N, time:Timestamp(Nanosecond, None), with space:Float64;N]
+  Sort: data.time ASC NULLS LAST [TIME:Boolean;N, bar:Dictionary(Int32, Utf8);N, bool_field:Boolean;N, f64_field:Float64;N, foo:Dictionary(Int32, Utf8);N, i64_field:Int64;N, mixedCase:Float64;N, str_field:Utf8;N, time:Timestamp(Nanosecond, None), with space:Float64;N]
+    Filter: CAST(data.foo AS Utf8) !~ Utf8("f") [TIME:Boolean;N, bar:Dictionary(Int32, Utf8);N, bool_field:Boolean;N, f64_field:Float64;N, foo:Dictionary(Int32, Utf8);N, i64_field:Int64;N, mixedCase:Float64;N, str_field:Utf8;N, time:Timestamp(Nanosecond, None), with space:Float64;N]
+      TableScan: data [TIME:Boolean;N, bar:Dictionary(Int32, Utf8);N, bool_field:Boolean;N, f64_field:Float64;N, foo:Dictionary(Int32, Utf8);N, i64_field:Int64;N, mixedCase:Float64;N, str_field:Utf8;N, time:Timestamp(Nanosecond, None), with space:Float64;N]
--- a/iox_query/src/plan/influxql/snapshots/iox_queryplaninfluxqlplannertestselecttime_range_in_where-9.snap
+++ b/iox_query/src/plan/influxql/snapshots/iox_queryplaninfluxqlplannertestselecttime_range_in_where-9.snap
@ -3,5 +3,6 @@ source: iox_query/src/plan/influxql/planner.rs
 expression: "plan(\"SELECT foo, f64_field FROM data where f64_field !~ /f/\").await"
 ---
 Projection: data.time, data.foo AS foo, data.f64_field AS f64_field [time:Timestamp(Nanosecond, None), foo:Dictionary(Int32, Utf8);N, f64_field:Float64;N]
-  Filter: Boolean(false) [TIME:Boolean;N, bar:Dictionary(Int32, Utf8);N, bool_field:Boolean;N, f64_field:Float64;N, foo:Dictionary(Int32, Utf8);N, i64_field:Int64;N, mixedCase:Float64;N, str_field:Utf8;N, time:Timestamp(Nanosecond, None), with space:Float64;N]
-    TableScan: data [TIME:Boolean;N, bar:Dictionary(Int32, Utf8);N, bool_field:Boolean;N, f64_field:Float64;N, foo:Dictionary(Int32, Utf8);N, i64_field:Int64;N, mixedCase:Float64;N, str_field:Utf8;N, time:Timestamp(Nanosecond, None), with space:Float64;N]
+  Sort: data.time ASC NULLS LAST [TIME:Boolean;N, bar:Dictionary(Int32, Utf8);N, bool_field:Boolean;N, f64_field:Float64;N, foo:Dictionary(Int32, Utf8);N, i64_field:Int64;N, mixedCase:Float64;N, str_field:Utf8;N, time:Timestamp(Nanosecond, None), with space:Float64;N]
+    Filter: Boolean(false) [TIME:Boolean;N, bar:Dictionary(Int32, Utf8);N, bool_field:Boolean;N, f64_field:Float64;N, foo:Dictionary(Int32, Utf8);N, i64_field:Int64;N, mixedCase:Float64;N, str_field:Utf8;N, time:Timestamp(Nanosecond, None), with space:Float64;N]
+      TableScan: data [TIME:Boolean;N, bar:Dictionary(Int32, Utf8);N, bool_field:Boolean;N, f64_field:Float64;N, foo:Dictionary(Int32, Utf8);N, i64_field:Int64;N, mixedCase:Float64;N, str_field:Utf8;N, time:Timestamp(Nanosecond, None), with space:Float64;N]
--- a/iox_query/src/plan/influxql/snapshots/iox_queryplaninfluxqlplannertestselecttime_range_in_where.snap
+++ b/iox_query/src/plan/influxql/snapshots/iox_queryplaninfluxqlplannertestselecttime_range_in_where.snap
@ -3,5 +3,6 @@ source: iox_query/src/plan/influxql/planner.rs
 expression: "plan(\"SELECT foo, f64_field FROM data where time > now() - 10s\").await"
 ---
 Projection: data.time, data.foo AS foo, data.f64_field AS f64_field [time:Timestamp(Nanosecond, None), foo:Dictionary(Int32, Utf8);N, f64_field:Float64;N]
-  Filter: data.time > now() - IntervalMonthDayNano("10000000000") [TIME:Boolean;N, bar:Dictionary(Int32, Utf8);N, bool_field:Boolean;N, f64_field:Float64;N, foo:Dictionary(Int32, Utf8);N, i64_field:Int64;N, mixedCase:Float64;N, str_field:Utf8;N, time:Timestamp(Nanosecond, None), with space:Float64;N]
-    TableScan: data [TIME:Boolean;N, bar:Dictionary(Int32, Utf8);N, bool_field:Boolean;N, f64_field:Float64;N, foo:Dictionary(Int32, Utf8);N, i64_field:Int64;N, mixedCase:Float64;N, str_field:Utf8;N, time:Timestamp(Nanosecond, None), with space:Float64;N]
+  Sort: data.time ASC NULLS LAST [TIME:Boolean;N, bar:Dictionary(Int32, Utf8);N, bool_field:Boolean;N, f64_field:Float64;N, foo:Dictionary(Int32, Utf8);N, i64_field:Int64;N, mixedCase:Float64;N, str_field:Utf8;N, time:Timestamp(Nanosecond, None), with space:Float64;N]
+    Filter: data.time > now() - IntervalMonthDayNano("10000000000") [TIME:Boolean;N, bar:Dictionary(Int32, Utf8);N, bool_field:Boolean;N, f64_field:Float64;N, foo:Dictionary(Int32, Utf8);N, i64_field:Int64;N, mixedCase:Float64;N, str_field:Utf8;N, time:Timestamp(Nanosecond, None), with space:Float64;N]
+      TableScan: data [TIME:Boolean;N, bar:Dictionary(Int32, Utf8);N, bool_field:Boolean;N, f64_field:Float64;N, foo:Dictionary(Int32, Utf8);N, i64_field:Int64;N, mixedCase:Float64;N, str_field:Utf8;N, time:Timestamp(Nanosecond, None), with space:Float64;N]
--- a/iox_query/src/plan/influxql/snapshots/iox_queryplaninfluxqlplannertest__select_raw__simple_arithmetic_in_projection-2.snap
+++ b/iox_query/src/plan/influxql/snapshots/iox_queryplaninfluxqlplannertest__select_raw__simple_arithmetic_in_projection-2.snap
@ -1,6 +1,7 @@
 ---
-source: iox_query/src/plan/influxql.rs
-expression: "plan(\"SELECT foo, sin(f64_field) FROM data\")"
+source: iox_query/src/plan/influxql/planner.rs
+expression: "plan(\"SELECT foo, sin(f64_field) FROM data\").await"
 ---
 Projection: data.time, data.foo AS foo, sin(data.f64_field) AS sin [time:Timestamp(Nanosecond, None), foo:Dictionary(Int32, Utf8);N, sin:Float64;N]
-  TableScan: data [TIME:Boolean;N, bar:Dictionary(Int32, Utf8);N, bool_field:Boolean;N, f64_field:Float64;N, foo:Dictionary(Int32, Utf8);N, i64_field:Int64;N, mixedCase:Float64;N, str_field:Utf8;N, time:Timestamp(Nanosecond, None), with space:Float64;N]
+  Sort: data.time ASC NULLS LAST [TIME:Boolean;N, bar:Dictionary(Int32, Utf8);N, bool_field:Boolean;N, f64_field:Float64;N, foo:Dictionary(Int32, Utf8);N, i64_field:Int64;N, mixedCase:Float64;N, str_field:Utf8;N, time:Timestamp(Nanosecond, None), with space:Float64;N]
+    TableScan: data [TIME:Boolean;N, bar:Dictionary(Int32, Utf8);N, bool_field:Boolean;N, f64_field:Float64;N, foo:Dictionary(Int32, Utf8);N, i64_field:Int64;N, mixedCase:Float64;N, str_field:Utf8;N, time:Timestamp(Nanosecond, None), with space:Float64;N]
--- a/iox_query/src/plan/influxql/snapshots/iox_queryplaninfluxqlplannertest__select_raw__simple_arithmetic_in_projection-3.snap
+++ b/iox_query/src/plan/influxql/snapshots/iox_queryplaninfluxqlplannertest__select_raw__simple_arithmetic_in_projection-3.snap
@ -1,6 +1,7 @@
 ---
-source: iox_query/src/plan/influxql.rs
-expression: "plan(\"SELECT foo, atan2(f64_field, 2) FROM data\")"
+source: iox_query/src/plan/influxql/planner.rs
+expression: "plan(\"SELECT foo, atan2(f64_field, 2) FROM data\").await"
 ---
 Projection: data.time, data.foo AS foo, atan2(data.f64_field, Int64(2)) AS atan2 [time:Timestamp(Nanosecond, None), foo:Dictionary(Int32, Utf8);N, atan2:Float64;N]
-  TableScan: data [TIME:Boolean;N, bar:Dictionary(Int32, Utf8);N, bool_field:Boolean;N, f64_field:Float64;N, foo:Dictionary(Int32, Utf8);N, i64_field:Int64;N, mixedCase:Float64;N, str_field:Utf8;N, time:Timestamp(Nanosecond, None), with space:Float64;N]
+  Sort: data.time ASC NULLS LAST [TIME:Boolean;N, bar:Dictionary(Int32, Utf8);N, bool_field:Boolean;N, f64_field:Float64;N, foo:Dictionary(Int32, Utf8);N, i64_field:Int64;N, mixedCase:Float64;N, str_field:Utf8;N, time:Timestamp(Nanosecond, None), with space:Float64;N]
+    TableScan: data [TIME:Boolean;N, bar:Dictionary(Int32, Utf8);N, bool_field:Boolean;N, f64_field:Float64;N, foo:Dictionary(Int32, Utf8);N, i64_field:Int64;N, mixedCase:Float64;N, str_field:Utf8;N, time:Timestamp(Nanosecond, None), with space:Float64;N]
--- a/iox_query/src/plan/influxql/snapshots/iox_queryplaninfluxqlplannertest__select_raw__simple_arithmetic_in_projection-4.snap
+++ b/iox_query/src/plan/influxql/snapshots/iox_queryplaninfluxqlplannertest__select_raw__simple_arithmetic_in_projection-4.snap
@ -1,6 +1,7 @@
 ---
-source: iox_query/src/plan/influxql.rs
-expression: "plan(\"SELECT foo, f64_field + 0.5 FROM data\")"
+source: iox_query/src/plan/influxql/planner.rs
+expression: "plan(\"SELECT foo, f64_field + 0.5 FROM data\").await"
 ---
 Projection: data.time, data.foo AS foo, data.f64_field + Float64(0.5) AS f64_field [time:Timestamp(Nanosecond, None), foo:Dictionary(Int32, Utf8);N, f64_field:Float64;N]
-  TableScan: data [TIME:Boolean;N, bar:Dictionary(Int32, Utf8);N, bool_field:Boolean;N, f64_field:Float64;N, foo:Dictionary(Int32, Utf8);N, i64_field:Int64;N, mixedCase:Float64;N, str_field:Utf8;N, time:Timestamp(Nanosecond, None), with space:Float64;N]
+  Sort: data.time ASC NULLS LAST [TIME:Boolean;N, bar:Dictionary(Int32, Utf8);N, bool_field:Boolean;N, f64_field:Float64;N, foo:Dictionary(Int32, Utf8);N, i64_field:Int64;N, mixedCase:Float64;N, str_field:Utf8;N, time:Timestamp(Nanosecond, None), with space:Float64;N]
+    TableScan: data [TIME:Boolean;N, bar:Dictionary(Int32, Utf8);N, bool_field:Boolean;N, f64_field:Float64;N, foo:Dictionary(Int32, Utf8);N, i64_field:Int64;N, mixedCase:Float64;N, str_field:Utf8;N, time:Timestamp(Nanosecond, None), with space:Float64;N]
--- a/iox_query/src/plan/influxql/snapshots/iox_queryplaninfluxqlplannertest__select_raw__simple_arithmetic_in_projection.snap
+++ b/iox_query/src/plan/influxql/snapshots/iox_queryplaninfluxqlplannertest__select_raw__simple_arithmetic_in_projection.snap
@ -1,6 +1,7 @@
 ---
-source: iox_query/src/plan/influxql.rs
-expression: "plan(\"SELECT foo, f64_field + f64_field FROM data\")"
+source: iox_query/src/plan/influxql/planner.rs
+expression: "plan(\"SELECT foo, f64_field + f64_field FROM data\").await"
 ---
 Projection: data.time, data.foo AS foo, data.f64_field + data.f64_field AS f64_field_f64_field [time:Timestamp(Nanosecond, None), foo:Dictionary(Int32, Utf8);N, f64_field_f64_field:Float64;N]
-  TableScan: data [TIME:Boolean;N, bar:Dictionary(Int32, Utf8);N, bool_field:Boolean;N, f64_field:Float64;N, foo:Dictionary(Int32, Utf8);N, i64_field:Int64;N, mixedCase:Float64;N, str_field:Utf8;N, time:Timestamp(Nanosecond, None), with space:Float64;N]
+  Sort: data.time ASC NULLS LAST [TIME:Boolean;N, bar:Dictionary(Int32, Utf8);N, bool_field:Boolean;N, f64_field:Float64;N, foo:Dictionary(Int32, Utf8);N, i64_field:Int64;N, mixedCase:Float64;N, str_field:Utf8;N, time:Timestamp(Nanosecond, None), with space:Float64;N]
+    TableScan: data [TIME:Boolean;N, bar:Dictionary(Int32, Utf8);N, bool_field:Boolean;N, f64_field:Float64;N, foo:Dictionary(Int32, Utf8);N, i64_field:Int64;N, mixedCase:Float64;N, str_field:Utf8;N, time:Timestamp(Nanosecond, None), with space:Float64;N]
--- a/iox_query/src/plan/influxql/snapshots/iox_queryplaninfluxqlplannertest__select_raw__single_measurement-2.snap
+++ b/iox_query/src/plan/influxql/snapshots/iox_queryplaninfluxqlplannertest__select_raw__single_measurement-2.snap
@ -1,6 +1,7 @@
 ---
-source: iox_query/src/plan/influxql.rs
-expression: "plan(\"SELECT time, f64_field FROM data\")"
+source: iox_query/src/plan/influxql/planner.rs
+expression: "plan(\"SELECT time, f64_field FROM data\").await"
 ---
 Projection: data.time AS time, data.f64_field AS f64_field [time:Timestamp(Nanosecond, None), f64_field:Float64;N]
-  TableScan: data [TIME:Boolean;N, bar:Dictionary(Int32, Utf8);N, bool_field:Boolean;N, f64_field:Float64;N, foo:Dictionary(Int32, Utf8);N, i64_field:Int64;N, mixedCase:Float64;N, str_field:Utf8;N, time:Timestamp(Nanosecond, None), with space:Float64;N]
+  Sort: data.time ASC NULLS LAST [TIME:Boolean;N, bar:Dictionary(Int32, Utf8);N, bool_field:Boolean;N, f64_field:Float64;N, foo:Dictionary(Int32, Utf8);N, i64_field:Int64;N, mixedCase:Float64;N, str_field:Utf8;N, time:Timestamp(Nanosecond, None), with space:Float64;N]
+    TableScan: data [TIME:Boolean;N, bar:Dictionary(Int32, Utf8);N, bool_field:Boolean;N, f64_field:Float64;N, foo:Dictionary(Int32, Utf8);N, i64_field:Int64;N, mixedCase:Float64;N, str_field:Utf8;N, time:Timestamp(Nanosecond, None), with space:Float64;N]
--- a/iox_query/src/plan/influxql/snapshots/iox_queryplaninfluxqlplannertest__select_raw__single_measurement-3.snap
+++ b/iox_query/src/plan/influxql/snapshots/iox_queryplaninfluxqlplannertest__select_raw__single_measurement-3.snap
@ -1,6 +1,7 @@
 ---
-source: iox_query/src/plan/influxql.rs
-expression: "plan(\"SELECT time as timestamp, f64_field FROM data\")"
+source: iox_query/src/plan/influxql/planner.rs
+expression: "plan(\"SELECT time as timestamp, f64_field FROM data\").await"
 ---
 Projection: data.time AS timestamp, data.f64_field AS f64_field [timestamp:Timestamp(Nanosecond, None), f64_field:Float64;N]
-  TableScan: data [TIME:Boolean;N, bar:Dictionary(Int32, Utf8);N, bool_field:Boolean;N, f64_field:Float64;N, foo:Dictionary(Int32, Utf8);N, i64_field:Int64;N, mixedCase:Float64;N, str_field:Utf8;N, time:Timestamp(Nanosecond, None), with space:Float64;N]
+  Sort: data.time ASC NULLS LAST [TIME:Boolean;N, bar:Dictionary(Int32, Utf8);N, bool_field:Boolean;N, f64_field:Float64;N, foo:Dictionary(Int32, Utf8);N, i64_field:Int64;N, mixedCase:Float64;N, str_field:Utf8;N, time:Timestamp(Nanosecond, None), with space:Float64;N]
+    TableScan: data [TIME:Boolean;N, bar:Dictionary(Int32, Utf8);N, bool_field:Boolean;N, f64_field:Float64;N, foo:Dictionary(Int32, Utf8);N, i64_field:Int64;N, mixedCase:Float64;N, str_field:Utf8;N, time:Timestamp(Nanosecond, None), with space:Float64;N]
--- a/iox_query/src/plan/influxql/snapshots/iox_queryplaninfluxqlplannertest__select_raw__single_measurement-4.snap
+++ b/iox_query/src/plan/influxql/snapshots/iox_queryplaninfluxqlplannertest__select_raw__single_measurement-4.snap
@ -1,6 +1,7 @@
 ---
-source: iox_query/src/plan/influxql.rs
-expression: "plan(\"SELECT foo, f64_field FROM data\")"
+source: iox_query/src/plan/influxql/planner.rs
+expression: "plan(\"SELECT foo, f64_field FROM data\").await"
 ---
 Projection: data.time, data.foo AS foo, data.f64_field AS f64_field [time:Timestamp(Nanosecond, None), foo:Dictionary(Int32, Utf8);N, f64_field:Float64;N]
-  TableScan: data [TIME:Boolean;N, bar:Dictionary(Int32, Utf8);N, bool_field:Boolean;N, f64_field:Float64;N, foo:Dictionary(Int32, Utf8);N, i64_field:Int64;N, mixedCase:Float64;N, str_field:Utf8;N, time:Timestamp(Nanosecond, None), with space:Float64;N]
+  Sort: data.time ASC NULLS LAST [TIME:Boolean;N, bar:Dictionary(Int32, Utf8);N, bool_field:Boolean;N, f64_field:Float64;N, foo:Dictionary(Int32, Utf8);N, i64_field:Int64;N, mixedCase:Float64;N, str_field:Utf8;N, time:Timestamp(Nanosecond, None), with space:Float64;N]
+    TableScan: data [TIME:Boolean;N, bar:Dictionary(Int32, Utf8);N, bool_field:Boolean;N, f64_field:Float64;N, foo:Dictionary(Int32, Utf8);N, i64_field:Int64;N, mixedCase:Float64;N, str_field:Utf8;N, time:Timestamp(Nanosecond, None), with space:Float64;N]
--- a/iox_query/src/plan/influxql/snapshots/iox_queryplaninfluxqlplannertest__select_raw__single_measurement-5.snap
+++ b/iox_query/src/plan/influxql/snapshots/iox_queryplaninfluxqlplannertest__select_raw__single_measurement-5.snap
@ -1,6 +1,7 @@
 ---
-source: iox_query/src/plan/influxql.rs
-expression: "plan(\"SELECT foo, f64_field, i64_field FROM data\")"
+source: iox_query/src/plan/influxql/planner.rs
+expression: "plan(\"SELECT foo, f64_field, i64_field FROM data\").await"
 ---
 Projection: data.time, data.foo AS foo, data.f64_field AS f64_field, data.i64_field AS i64_field [time:Timestamp(Nanosecond, None), foo:Dictionary(Int32, Utf8);N, f64_field:Float64;N, i64_field:Int64;N]
-  TableScan: data [TIME:Boolean;N, bar:Dictionary(Int32, Utf8);N, bool_field:Boolean;N, f64_field:Float64;N, foo:Dictionary(Int32, Utf8);N, i64_field:Int64;N, mixedCase:Float64;N, str_field:Utf8;N, time:Timestamp(Nanosecond, None), with space:Float64;N]
+  Sort: data.time ASC NULLS LAST [TIME:Boolean;N, bar:Dictionary(Int32, Utf8);N, bool_field:Boolean;N, f64_field:Float64;N, foo:Dictionary(Int32, Utf8);N, i64_field:Int64;N, mixedCase:Float64;N, str_field:Utf8;N, time:Timestamp(Nanosecond, None), with space:Float64;N]
+    TableScan: data [TIME:Boolean;N, bar:Dictionary(Int32, Utf8);N, bool_field:Boolean;N, f64_field:Float64;N, foo:Dictionary(Int32, Utf8);N, i64_field:Int64;N, mixedCase:Float64;N, str_field:Utf8;N, time:Timestamp(Nanosecond, None), with space:Float64;N]
--- a/iox_query/src/plan/influxql/snapshots/iox_queryplaninfluxqlplannertest__select_raw__single_measurement-6.snap
+++ b/iox_query/src/plan/influxql/snapshots/iox_queryplaninfluxqlplannertest__select_raw__single_measurement-6.snap
@ -1,6 +1,7 @@
 ---
-source: iox_query/src/plan/influxql.rs
-expression: "plan(\"SELECT /^f/ FROM data\")"
+source: iox_query/src/plan/influxql/planner.rs
+expression: "plan(\"SELECT /^f/ FROM data\").await"
 ---
 Projection: data.time, data.f64_field AS f64_field, data.foo AS foo [time:Timestamp(Nanosecond, None), f64_field:Float64;N, foo:Dictionary(Int32, Utf8);N]
-  TableScan: data [TIME:Boolean;N, bar:Dictionary(Int32, Utf8);N, bool_field:Boolean;N, f64_field:Float64;N, foo:Dictionary(Int32, Utf8);N, i64_field:Int64;N, mixedCase:Float64;N, str_field:Utf8;N, time:Timestamp(Nanosecond, None), with space:Float64;N]
+  Sort: data.time ASC NULLS LAST [TIME:Boolean;N, bar:Dictionary(Int32, Utf8);N, bool_field:Boolean;N, f64_field:Float64;N, foo:Dictionary(Int32, Utf8);N, i64_field:Int64;N, mixedCase:Float64;N, str_field:Utf8;N, time:Timestamp(Nanosecond, None), with space:Float64;N]
+    TableScan: data [TIME:Boolean;N, bar:Dictionary(Int32, Utf8);N, bool_field:Boolean;N, f64_field:Float64;N, foo:Dictionary(Int32, Utf8);N, i64_field:Int64;N, mixedCase:Float64;N, str_field:Utf8;N, time:Timestamp(Nanosecond, None), with space:Float64;N]
--- a/iox_query/src/plan/influxql/snapshots/iox_queryplaninfluxqlplannertest__select_raw__single_measurement-7.snap
+++ b/iox_query/src/plan/influxql/snapshots/iox_queryplaninfluxqlplannertest__select_raw__single_measurement-7.snap
@ -1,6 +1,7 @@
 ---
-source: iox_query/src/plan/influxql.rs
-expression: "plan(\"SELECT * FROM data\")"
+source: iox_query/src/plan/influxql/planner.rs
+expression: "plan(\"SELECT * FROM data\").await"
 ---
 Projection: data.time, data.TIME AS TIME, data.bar AS bar, data.bool_field AS bool_field, data.f64_field AS f64_field, data.foo AS foo, data.i64_field AS i64_field, data.mixedCase AS mixedCase, data.str_field AS str_field, data.with space AS with space [time:Timestamp(Nanosecond, None), TIME:Boolean;N, bar:Dictionary(Int32, Utf8);N, bool_field:Boolean;N, f64_field:Float64;N, foo:Dictionary(Int32, Utf8);N, i64_field:Int64;N, mixedCase:Float64;N, str_field:Utf8;N, with space:Float64;N]
-  TableScan: data [TIME:Boolean;N, bar:Dictionary(Int32, Utf8);N, bool_field:Boolean;N, f64_field:Float64;N, foo:Dictionary(Int32, Utf8);N, i64_field:Int64;N, mixedCase:Float64;N, str_field:Utf8;N, time:Timestamp(Nanosecond, None), with space:Float64;N]
+  Sort: data.time ASC NULLS LAST [TIME:Boolean;N, bar:Dictionary(Int32, Utf8);N, bool_field:Boolean;N, f64_field:Float64;N, foo:Dictionary(Int32, Utf8);N, i64_field:Int64;N, mixedCase:Float64;N, str_field:Utf8;N, time:Timestamp(Nanosecond, None), with space:Float64;N]
+    TableScan: data [TIME:Boolean;N, bar:Dictionary(Int32, Utf8);N, bool_field:Boolean;N, f64_field:Float64;N, foo:Dictionary(Int32, Utf8);N, i64_field:Int64;N, mixedCase:Float64;N, str_field:Utf8;N, time:Timestamp(Nanosecond, None), with space:Float64;N]
--- a/iox_query/src/plan/influxql/snapshots/iox_queryplaninfluxqlplannertest__select_raw__single_measurement-8.snap
+++ b/iox_query/src/plan/influxql/snapshots/iox_queryplaninfluxqlplannertest__select_raw__single_measurement-8.snap
@ -1,6 +1,7 @@
 ---
-source: iox_query/src/plan/influxql.rs
-expression: "plan(\"SELECT TIME FROM data\")"
+source: iox_query/src/plan/influxql/planner.rs
+expression: "plan(\"SELECT TIME FROM data\").await"
 ---
 Projection: data.time, data.TIME AS TIME [time:Timestamp(Nanosecond, None), TIME:Boolean;N]
-  TableScan: data [TIME:Boolean;N, bar:Dictionary(Int32, Utf8);N, bool_field:Boolean;N, f64_field:Float64;N, foo:Dictionary(Int32, Utf8);N, i64_field:Int64;N, mixedCase:Float64;N, str_field:Utf8;N, time:Timestamp(Nanosecond, None), with space:Float64;N]
+  Sort: data.time ASC NULLS LAST [TIME:Boolean;N, bar:Dictionary(Int32, Utf8);N, bool_field:Boolean;N, f64_field:Float64;N, foo:Dictionary(Int32, Utf8);N, i64_field:Int64;N, mixedCase:Float64;N, str_field:Utf8;N, time:Timestamp(Nanosecond, None), with space:Float64;N]
+    TableScan: data [TIME:Boolean;N, bar:Dictionary(Int32, Utf8);N, bool_field:Boolean;N, f64_field:Float64;N, foo:Dictionary(Int32, Utf8);N, i64_field:Int64;N, mixedCase:Float64;N, str_field:Utf8;N, time:Timestamp(Nanosecond, None), with space:Float64;N]
--- a/iox_query/src/plan/influxql/snapshots/iox_queryplaninfluxqlplannertest__select_raw__single_measurement.snap
+++ b/iox_query/src/plan/influxql/snapshots/iox_queryplaninfluxqlplannertest__select_raw__single_measurement.snap
@ -1,6 +1,7 @@
 ---
-source: iox_query/src/plan/influxql.rs
-expression: "plan(\"SELECT f64_field FROM data\")"
+source: iox_query/src/plan/influxql/planner.rs
+expression: "plan(\"SELECT f64_field FROM data\").await"
 ---
 Projection: data.time, data.f64_field AS f64_field [time:Timestamp(Nanosecond, None), f64_field:Float64;N]
-  TableScan: data [TIME:Boolean;N, bar:Dictionary(Int32, Utf8);N, bool_field:Boolean;N, f64_field:Float64;N, foo:Dictionary(Int32, Utf8);N, i64_field:Int64;N, mixedCase:Float64;N, str_field:Utf8;N, time:Timestamp(Nanosecond, None), with space:Float64;N]
+  Sort: data.time ASC NULLS LAST [TIME:Boolean;N, bar:Dictionary(Int32, Utf8);N, bool_field:Boolean;N, f64_field:Float64;N, foo:Dictionary(Int32, Utf8);N, i64_field:Int64;N, mixedCase:Float64;N, str_field:Utf8;N, time:Timestamp(Nanosecond, None), with space:Float64;N]
+    TableScan: data [TIME:Boolean;N, bar:Dictionary(Int32, Utf8);N, bool_field:Boolean;N, f64_field:Float64;N, foo:Dictionary(Int32, Utf8);N, i64_field:Int64;N, mixedCase:Float64;N, str_field:Utf8;N, time:Timestamp(Nanosecond, None), with space:Float64;N]
--- a/iox_query/src/plan/influxql/snapshots/iox_queryplaninfluxqlplannertest__unsupported_statements-10.snap
+++ b/iox_query/src/plan/influxql/snapshots/iox_queryplaninfluxqlplannertest__unsupported_statements-10.snap
@ -1,5 +0,0 @@
---
-source: iox_query/src/plan/influxql.rs
-expression: "plan(\"SHOW FIELD KEYS\")"
---
-This feature is not implemented: SHOW FIELD KEYS
--- a/iox_query/src/plan/influxql/snapshots/iox_queryplaninfluxqlplannertest__unsupported_statements-4.snap
+++ b/iox_query/src/plan/influxql/snapshots/iox_queryplaninfluxqlplannertest__unsupported_statements-4.snap
@ -1,5 +1,5 @@
 ---
-source: iox_query/src/plan/influxql.rs
-expression: "plan(\"EXPLAIN SELECT bar FROM foo\")"
+source: iox_query/src/plan/influxql/planner.rs
+expression: "plan(\"SHOW DATABASES\").await"
 ---
-This feature is not implemented: EXPLAIN
+This feature is not implemented: SHOW DATABASES
--- a/iox_query/src/plan/influxql/snapshots/iox_queryplaninfluxqlplannertest__unsupported_statements-5.snap
+++ b/iox_query/src/plan/influxql/snapshots/iox_queryplaninfluxqlplannertest__unsupported_statements-5.snap
@ -1,5 +1,5 @@
 ---
-source: iox_query/src/plan/influxql.rs
-expression: "plan(\"SHOW DATABASES\")"
+source: iox_query/src/plan/influxql/planner.rs
+expression: "plan(\"SHOW MEASUREMENTS\").await"
 ---
-This feature is not implemented: SHOW DATABASES
+This feature is not implemented: SHOW MEASUREMENTS
--- a/iox_query/src/plan/influxql/snapshots/iox_queryplaninfluxqlplannertest__unsupported_statements-6.snap
+++ b/iox_query/src/plan/influxql/snapshots/iox_queryplaninfluxqlplannertest__unsupported_statements-6.snap
@ -1,5 +1,5 @@
 ---
-source: iox_query/src/plan/influxql.rs
-expression: "plan(\"SHOW MEASUREMENTS\")"
+source: iox_query/src/plan/influxql/planner.rs
+expression: "plan(\"SHOW RETENTION POLICIES\").await"
 ---
-This feature is not implemented: SHOW MEASUREMENTS
+This feature is not implemented: SHOW RETENTION POLICIES
--- a/iox_query/src/plan/influxql/snapshots/iox_queryplaninfluxqlplannertest__unsupported_statements-7.snap
+++ b/iox_query/src/plan/influxql/snapshots/iox_queryplaninfluxqlplannertest__unsupported_statements-7.snap
@ -1,5 +1,5 @@
 ---
-source: iox_query/src/plan/influxql.rs
-expression: "plan(\"SHOW RETENTION POLICIES\")"
+source: iox_query/src/plan/influxql/planner.rs
+expression: "plan(\"SHOW TAG KEYS\").await"
 ---
-This feature is not implemented: SHOW RETENTION POLICIES
+This feature is not implemented: SHOW TAG KEYS
--- a/iox_query/src/plan/influxql/snapshots/iox_queryplaninfluxqlplannertest__unsupported_statements-8.snap
+++ b/iox_query/src/plan/influxql/snapshots/iox_queryplaninfluxqlplannertest__unsupported_statements-8.snap
@ -1,5 +1,5 @@
 ---
-source: iox_query/src/plan/influxql.rs
-expression: "plan(\"SHOW TAG KEYS\")"
+source: iox_query/src/plan/influxql/planner.rs
+expression: "plan(\"SHOW TAG VALUES WITH KEY = bar\").await"
 ---
-This feature is not implemented: SHOW TAG KEYS
+This feature is not implemented: SHOW TAG VALUES
--- a/iox_query/src/plan/influxql/snapshots/iox_queryplaninfluxqlplannertest__unsupported_statements-9.snap
+++ b/iox_query/src/plan/influxql/snapshots/iox_queryplaninfluxqlplannertest__unsupported_statements-9.snap
@ -1,5 +1,5 @@
 ---
-source: iox_query/src/plan/influxql.rs
-expression: "plan(\"SHOW TAG VALUES WITH KEY = bar\")"
+source: iox_query/src/plan/influxql/planner.rs
+expression: "plan(\"SHOW FIELD KEYS\").await"
 ---
-This feature is not implemented: SHOW TAG VALUES
+This feature is not implemented: SHOW FIELD KEYS