Apache DataFusion SQL Query Engine
Use strum in the examples (#19126) (#19205)
Sergey Zhukovdc6a71235b3d
diff --git a/Cargo.lock b/Cargo.lockindex 25f9781be8..85872c4fa7 100644--- a/Cargo.lock+++ b/Cargo.lock@@ -2215,6 +2215,8 @@ dependencies = ["prost","rand 0.9.2","serde_json",+ "strum 0.27.2",+ "strum_macros 0.27.2","tempfile","test-utils","tokio",diff --git a/Cargo.toml b/Cargo.tomlindex dd6543db98..9632d3397d 100644--- a/Cargo.toml+++ b/Cargo.toml@@ -182,6 +182,8 @@ regex = "1.12"rstest = "0.26.1"serde_json = "1"sqlparser = { version = "0.59.0", default-features = false, features = ["std", "visitor"] }+strum = "0.27.2"+strum_macros = "0.27.2"tempfile = "3"testcontainers = { version = "0.25.2", features = ["default"] }testcontainers-modules = { version = "0.13" }diff --git a/datafusion-examples/Cargo.toml b/datafusion-examples/Cargo.tomlindex e445184291..b0190dadf3 100644--- a/datafusion-examples/Cargo.toml+++ b/datafusion-examples/Cargo.toml@@ -60,6 +60,8 @@ object_store = { workspace = true, features = ["aws", "http"] }prost = { workspace = true }rand = { workspace = true }serde_json = { workspace = true }+strum = { workspace = true }+strum_macros = { workspace = true }tempfile = { workspace = true }test-utils = { path = "../test-utils" }tokio = { workspace = true, features = ["rt-multi-thread", "parking_lot"] }diff --git a/datafusion-examples/examples/builtin_functions/main.rs b/datafusion-examples/examples/builtin_functions/main.rsindex f0aa241a6e..f9e0a44a09 100644--- a/datafusion-examples/examples/builtin_functions/main.rs+++ b/datafusion-examples/examples/builtin_functions/main.rs@@ -34,10 +34,12 @@ mod date_time;mod function_factory;mod regexp;-use std::str::FromStr;-use datafusion::error::{DataFusionError, Result};+use strum::{IntoEnumIterator, VariantNames};+use strum_macros::{Display, EnumIter, EnumString, VariantNames};+#[derive(EnumIter, EnumString, Display, VariantNames)]+#[strum(serialize_all = "snake_case")]enum ExampleKind {All,DateTime,@@ -45,56 +47,18 @@ enum ExampleKind {Regexp,}-impl AsRef<str> for ExampleKind {- fn as_ref(&self) -> &str {- match self {- Self::All => "all",- Self::DateTime => "date_time",- Self::FunctionFactory => "function_factory",- Self::Regexp => "regexp",- }- }-}--impl FromStr for ExampleKind {- type Err = DataFusionError;-- fn from_str(s: &str) -> Result<Self> {- match s {- "all" => Ok(Self::All),- "date_time" => Ok(Self::DateTime),- "function_factory" => Ok(Self::FunctionFactory),- "regexp" => Ok(Self::Regexp),- _ => Err(DataFusionError::Execution(format!("Unknown example: {s}"))),- }- }-}-impl ExampleKind {- const ALL_VARIANTS: [Self; 4] = [- Self::All,- Self::DateTime,- Self::FunctionFactory,- Self::Regexp,- ];-- const RUNNABLE_VARIANTS: [Self; 3] =- [Self::DateTime, Self::FunctionFactory, Self::Regexp];-const EXAMPLE_NAME: &str = "builtin_functions";- fn variants() -> Vec<&'static str> {- Self::ALL_VARIANTS- .iter()- .map(|example| example.as_ref())- .collect()+ fn runnable() -> impl Iterator<Item = ExampleKind> {+ ExampleKind::iter().filter(|v| !matches!(v, ExampleKind::All))}async fn run(&self) -> Result<()> {match self {ExampleKind::All => {- for example in ExampleKind::RUNNABLE_VARIANTS {- println!("Running example: {}", example.as_ref());+ for example in ExampleKind::runnable() {+ println!("Running example: {example}");Box::pin(example.run()).await?;}}@@ -111,14 +75,14 @@ async fn main() -> Result<()> {let usage = format!("Usage: cargo run --example {} -- [{}]",ExampleKind::EXAMPLE_NAME,- ExampleKind::variants().join("|")+ ExampleKind::VARIANTS.join("|"));- let arg = std::env::args().nth(1).ok_or_else(|| {- eprintln!("{usage}");- DataFusionError::Execution("Missing argument".to_string())- })?;+ let example: ExampleKind = std::env::args()+ .nth(1)+ .ok_or_else(|| DataFusionError::Execution(format!("Missing argument. {usage}")))?+ .parse()+ .map_err(|_| DataFusionError::Execution(format!("Unknown example. {usage}")))?;- let example = arg.parse::<ExampleKind>()?;example.run().await}diff --git a/datafusion-examples/examples/custom_data_source/main.rs b/datafusion-examples/examples/custom_data_source/main.rsindex 779d3ce6f0..b5dcf10f5c 100644--- a/datafusion-examples/examples/custom_data_source/main.rs+++ b/datafusion-examples/examples/custom_data_source/main.rs@@ -42,10 +42,12 @@ mod custom_file_format;mod default_column_values;mod file_stream_provider;-use std::str::FromStr;-use datafusion::error::{DataFusionError, Result};+use strum::{IntoEnumIterator, VariantNames};+use strum_macros::{Display, EnumIter, EnumString, VariantNames};+#[derive(EnumIter, EnumString, Display, VariantNames)]+#[strum(serialize_all = "snake_case")]enum ExampleKind {All,CsvJsonOpener,@@ -57,75 +59,18 @@ enum ExampleKind {FileStreamProvider,}-impl AsRef<str> for ExampleKind {- fn as_ref(&self) -> &str {- match self {- Self::All => "all",- Self::CsvJsonOpener => "csv_json_opener",- Self::CsvSqlStreaming => "csv_sql_streaming",- Self::CustomDatasource => "custom_datasource",- Self::CustomFileCasts => "custom_file_casts",- Self::CustomFileFormat => "custom_file_format",- Self::DefaultColumnValues => "default_column_values",- Self::FileStreamProvider => "file_stream_provider",- }- }-}--impl FromStr for ExampleKind {- type Err = DataFusionError;-- fn from_str(s: &str) -> Result<Self> {- match s {- "all" => Ok(Self::All),- "csv_json_opener" => Ok(Self::CsvJsonOpener),- "csv_sql_streaming" => Ok(Self::CsvSqlStreaming),- "custom_datasource" => Ok(Self::CustomDatasource),- "custom_file_casts" => Ok(Self::CustomFileCasts),- "custom_file_format" => Ok(Self::CustomFileFormat),- "default_column_values" => Ok(Self::DefaultColumnValues),- "file_stream_provider" => Ok(Self::FileStreamProvider),- _ => Err(DataFusionError::Execution(format!("Unknown example: {s}"))),- }- }-}-impl ExampleKind {- const ALL_VARIANTS: [Self; 8] = [- Self::All,- Self::CsvJsonOpener,- Self::CsvSqlStreaming,- Self::CustomDatasource,- Self::CustomFileCasts,- Self::CustomFileFormat,- Self::DefaultColumnValues,- Self::FileStreamProvider,- ];-- const RUNNABLE_VARIANTS: [Self; 7] = [- Self::CsvJsonOpener,- Self::CsvSqlStreaming,- Self::CustomDatasource,- Self::CustomFileCasts,- Self::CustomFileFormat,- Self::DefaultColumnValues,- Self::FileStreamProvider,- ];-const EXAMPLE_NAME: &str = "custom_data_source";- fn variants() -> Vec<&'static str> {- Self::ALL_VARIANTS- .iter()- .map(|example| example.as_ref())- .collect()+ fn runnable() -> impl Iterator<Item = ExampleKind> {+ ExampleKind::iter().filter(|v| !matches!(v, ExampleKind::All))}async fn run(&self) -> Result<()> {match self {ExampleKind::All => {- for example in ExampleKind::RUNNABLE_VARIANTS {- println!("Running example: {}", example.as_ref());+ for example in ExampleKind::runnable() {+ println!("Running example: {example}");Box::pin(example.run()).await?;}}@@ -158,14 +103,14 @@ async fn main() -> Result<()> {let usage = format!("Usage: cargo run --example {} -- [{}]",ExampleKind::EXAMPLE_NAME,- ExampleKind::variants().join("|")+ ExampleKind::VARIANTS.join("|"));- let arg = std::env::args().nth(1).ok_or_else(|| {- eprintln!("{usage}");- DataFusionError::Execution("Missing argument".to_string())- })?;+ let example: ExampleKind = std::env::args()+ .nth(1)+ .ok_or_else(|| DataFusionError::Execution(format!("Missing argument. {usage}")))?+ .parse()+ .map_err(|_| DataFusionError::Execution(format!("Unknown example. {usage}")))?;- let example = arg.parse::<ExampleKind>()?;example.run().await}diff --git a/datafusion-examples/examples/data_io/main.rs b/datafusion-examples/examples/data_io/main.rsindex 3466eeedf1..496a588d40 100644--- a/datafusion-examples/examples/data_io/main.rs+++ b/datafusion-examples/examples/data_io/main.rs@@ -48,10 +48,12 @@ mod parquet_index;mod query_http_csv;mod remote_catalog;-use std::str::FromStr;-use datafusion::error::{DataFusionError, Result};+use strum::{IntoEnumIterator, VariantNames};+use strum_macros::{Display, EnumIter, EnumString, VariantNames};+#[derive(EnumIter, EnumString, Display, VariantNames)]+#[strum(serialize_all = "snake_case")]enum ExampleKind {All,Catalog,@@ -66,87 +68,18 @@ enum ExampleKind {RemoteCatalog,}-impl AsRef<str> for ExampleKind {- fn as_ref(&self) -> &str {- match self {- Self::All => "all",- Self::Catalog => "catalog",- Self::JsonShredding => "json_shredding",- Self::ParquetAdvIdx => "parquet_adv_idx",- Self::ParquetEmbIdx => "parquet_emb_idx",- Self::ParquetEnc => "parquet_enc",- Self::ParquetEncWithKms => "parquet_enc_with_kms",- Self::ParquetExecVisitor => "parquet_exec_visitor",- Self::ParquetIdx => "parquet_idx",- Self::QueryHttpCsv => "query_http_csv",- Self::RemoteCatalog => "remote_catalog",- }- }-}--impl FromStr for ExampleKind {- type Err = DataFusionError;-- fn from_str(s: &str) -> Result<Self> {- match s {- "all" => Ok(Self::All),- "catalog" => Ok(Self::Catalog),- "json_shredding" => Ok(Self::JsonShredding),- "parquet_adv_idx" => Ok(Self::ParquetAdvIdx),- "parquet_emb_idx" => Ok(Self::ParquetEmbIdx),- "parquet_enc" => Ok(Self::ParquetEnc),- "parquet_enc_with_kms" => Ok(Self::ParquetEncWithKms),- "parquet_exec_visitor" => Ok(Self::ParquetExecVisitor),- "parquet_idx" => Ok(Self::ParquetIdx),- "query_http_csv" => Ok(Self::QueryHttpCsv),- "remote_catalog" => Ok(Self::RemoteCatalog),- _ => Err(DataFusionError::Execution(format!("Unknown example: {s}"))),- }- }-}-impl ExampleKind {- const ALL_VARIANTS: [Self; 11] = [- Self::All,- Self::Catalog,- Self::JsonShredding,- Self::ParquetAdvIdx,- Self::ParquetEmbIdx,- Self::ParquetEnc,- Self::ParquetEncWithKms,- Self::ParquetExecVisitor,- Self::ParquetIdx,- Self::QueryHttpCsv,- Self::RemoteCatalog,- ];-- const RUNNABLE_VARIANTS: [Self; 10] = [- Self::Catalog,- Self::JsonShredding,- Self::ParquetAdvIdx,- Self::ParquetEmbIdx,- Self::ParquetEnc,- Self::ParquetEncWithKms,- Self::ParquetExecVisitor,- Self::ParquetIdx,- Self::QueryHttpCsv,- Self::RemoteCatalog,- ];-const EXAMPLE_NAME: &str = "data_io";- fn variants() -> Vec<&'static str> {- Self::ALL_VARIANTS- .iter()- .map(|example| example.as_ref())- .collect()+ fn runnable() -> impl Iterator<Item = ExampleKind> {+ ExampleKind::iter().filter(|v| !matches!(v, ExampleKind::All))}async fn run(&self) -> Result<()> {match self {ExampleKind::All => {- for example in ExampleKind::RUNNABLE_VARIANTS {- println!("Running example: {}", example.as_ref());+ for example in ExampleKind::runnable() {+ println!("Running example: {example}");Box::pin(example.run()).await?;}}@@ -178,14 +111,14 @@ async fn main() -> Result<()> {let usage = format!("Usage: cargo run --example {} -- [{}]",ExampleKind::EXAMPLE_NAME,- ExampleKind::variants().join("|")+ ExampleKind::VARIANTS.join("|"));- let arg = std::env::args().nth(1).ok_or_else(|| {- eprintln!("{usage}");- DataFusionError::Execution("Missing argument".to_string())- })?;+ let example: ExampleKind = std::env::args()+ .nth(1)+ .ok_or_else(|| DataFusionError::Execution(format!("Missing argument. {usage}")))?+ .parse()+ .map_err(|_| DataFusionError::Execution(format!("Unknown example. {usage}")))?;- let example = arg.parse::<ExampleKind>()?;example.run().await}diff --git a/datafusion-examples/examples/dataframe/main.rs b/datafusion-examples/examples/dataframe/main.rsindex f6a7a025a8..2c52ec0d31 100644--- a/datafusion-examples/examples/dataframe/main.rs+++ b/datafusion-examples/examples/dataframe/main.rs@@ -32,65 +32,38 @@mod dataframe;mod deserialize_to_struct;-use std::str::FromStr;-use datafusion::error::{DataFusionError, Result};+use strum::{IntoEnumIterator, VariantNames};+use strum_macros::{Display, EnumIter, EnumString, VariantNames};+#[derive(EnumIter, EnumString, Display, VariantNames)]+#[strum(serialize_all = "snake_case")]enum ExampleKind {All,Dataframe,DeserializeToStruct,}-impl AsRef<str> for ExampleKind {- fn as_ref(&self) -> &str {- match self {- Self::All => "all",- Self::Dataframe => "dataframe",- Self::DeserializeToStruct => "deserialize_to_struct",- }- }-}--impl FromStr for ExampleKind {- type Err = DataFusionError;-- fn from_str(s: &str) -> Result<Self> {- match s {- "all" => Ok(Self::All),- "dataframe" => Ok(Self::Dataframe),- "deserialize_to_struct" => Ok(Self::DeserializeToStruct),- _ => Err(DataFusionError::Execution(format!("Unknown example: {s}"))),- }- }-}-impl ExampleKind {- const ALL_VARIANTS: [Self; 3] =- [Self::All, Self::Dataframe, Self::DeserializeToStruct];-- const RUNNABLE_VARIANTS: [Self; 2] = [Self::Dataframe, Self::DeserializeToStruct];-const EXAMPLE_NAME: &str = "dataframe";- fn variants() -> Vec<&'static str> {- Self::ALL_VARIANTS- .iter()- .map(|example| example.as_ref())- .collect()+ fn runnable() -> impl Iterator<Item = ExampleKind> {+ ExampleKind::iter().filter(|v| !matches!(v, ExampleKind::All))}async fn run(&self) -> Result<()> {match self {ExampleKind::All => {- for example in ExampleKind::RUNNABLE_VARIANTS {- println!("Running example: {}", example.as_ref());+ for example in ExampleKind::runnable() {+ println!("Running example: {example}");Box::pin(example.run()).await?;}}- ExampleKind::Dataframe => dataframe::dataframe_example().await?,+ ExampleKind::Dataframe => {+ dataframe::dataframe_example().await?;+ }ExampleKind::DeserializeToStruct => {- deserialize_to_struct::deserialize_to_struct().await?+ deserialize_to_struct::deserialize_to_struct().await?;}}Ok(())@@ -102,14 +75,14 @@ async fn main() -> Result<()> {let usage = format!("Usage: cargo run --example {} -- [{}]",ExampleKind::EXAMPLE_NAME,- ExampleKind::variants().join("|")+ ExampleKind::VARIANTS.join("|"));- let arg = std::env::args().nth(1).ok_or_else(|| {- eprintln!("{usage}");- DataFusionError::Execution("Missing argument".to_string())- })?;+ let example: ExampleKind = std::env::args()+ .nth(1)+ .ok_or_else(|| DataFusionError::Execution(format!("Missing argument. {usage}")))?+ .parse()+ .map_err(|_| DataFusionError::Execution(format!("Unknown example. {usage}")))?;- let example = arg.parse::<ExampleKind>()?;example.run().await}diff --git a/datafusion-examples/examples/execution_monitoring/main.rs b/datafusion-examples/examples/execution_monitoring/main.rsindex 39126968d1..3043a80363 100644--- a/datafusion-examples/examples/execution_monitoring/main.rs+++ b/datafusion-examples/examples/execution_monitoring/main.rs@@ -34,77 +34,38 @@ mod memory_pool_execution_plan;mod memory_pool_tracking;mod tracing;-use std::str::FromStr;-use datafusion::error::{DataFusionError, Result};+use strum::{IntoEnumIterator, VariantNames};+use strum_macros::{Display, EnumIter, EnumString, VariantNames};+#[derive(EnumIter, EnumString, Display, VariantNames)]+#[strum(serialize_all = "snake_case")]enum ExampleKind {All,- MemoryPoolExecutionPlan,- MemoryPoolTracking,+ MemPoolExecPlan,+ MemPoolTracking,Tracing,}-impl AsRef<str> for ExampleKind {- fn as_ref(&self) -> &str {- match self {- Self::All => "all",- Self::MemoryPoolExecutionPlan => "mem_pool_exec_plan",- Self::MemoryPoolTracking => "mem_pool_tracking",- Self::Tracing => "tracing",- }- }-}--impl FromStr for ExampleKind {- type Err = DataFusionError;-- fn from_str(s: &str) -> Result<Self> {- match s {- "all" => Ok(Self::All),- "mem_pool_exec_plan" => Ok(Self::MemoryPoolExecutionPlan),- "mem_pool_tracking" => Ok(Self::MemoryPoolTracking),- "tracing" => Ok(Self::Tracing),- _ => Err(DataFusionError::Execution(format!("Unknown example: {s}"))),- }- }-}-impl ExampleKind {- const ALL_VARIANTS: [Self; 4] = [- Self::All,- Self::MemoryPoolExecutionPlan,- Self::MemoryPoolTracking,- Self::Tracing,- ];-- const RUNNABLE_VARIANTS: [Self; 3] = [- Self::MemoryPoolExecutionPlan,- Self::MemoryPoolTracking,- Self::Tracing,- ];-const EXAMPLE_NAME: &str = "execution_monitoring";- fn variants() -> Vec<&'static str> {- Self::ALL_VARIANTS- .iter()- .map(|example| example.as_ref())- .collect()+ fn runnable() -> impl Iterator<Item = ExampleKind> {+ ExampleKind::iter().filter(|v| !matches!(v, ExampleKind::All))}async fn run(&self) -> Result<()> {match self {ExampleKind::All => {- for example in ExampleKind::RUNNABLE_VARIANTS {- println!("Running example: {}", example.as_ref());+ for example in ExampleKind::runnable() {+ println!("Running example: {example}");Box::pin(example.run()).await?;}}- ExampleKind::MemoryPoolExecutionPlan => {+ ExampleKind::MemPoolExecPlan => {memory_pool_execution_plan::memory_pool_execution_plan().await?}- ExampleKind::MemoryPoolTracking => {+ ExampleKind::MemPoolTracking => {memory_pool_tracking::mem_pool_tracking().await?}ExampleKind::Tracing => tracing::tracing().await?,@@ -118,14 +79,14 @@ async fn main() -> Result<()> {let usage = format!("Usage: cargo run --example {} -- [{}]",ExampleKind::EXAMPLE_NAME,- ExampleKind::variants().join("|")+ ExampleKind::VARIANTS.join("|"));- let arg = std::env::args().nth(1).ok_or_else(|| {- eprintln!("{usage}");- DataFusionError::Execution("Missing argument".to_string())- })?;+ let example: ExampleKind = std::env::args()+ .nth(1)+ .ok_or_else(|| DataFusionError::Execution(format!("Missing argument. {usage}")))?+ .parse()+ .map_err(|_| DataFusionError::Execution(format!("Unknown example. {usage}")))?;- let example = arg.parse::<ExampleKind>()?;example.run().await}diff --git a/datafusion-examples/examples/external_dependency/main.rs b/datafusion-examples/examples/external_dependency/main.rsindex 55b47ab9b7..abcba61421 100644--- a/datafusion-examples/examples/external_dependency/main.rs+++ b/datafusion-examples/examples/external_dependency/main.rs@@ -32,58 +32,30 @@mod dataframe_to_s3;mod query_aws_s3;-use std::str::FromStr;-use datafusion::error::{DataFusionError, Result};+use strum::{IntoEnumIterator, VariantNames};+use strum_macros::{Display, EnumIter, EnumString, VariantNames};+#[derive(EnumIter, EnumString, Display, VariantNames)]+#[strum(serialize_all = "snake_case")]enum ExampleKind {All,DataframeToS3,QueryAwsS3,}-impl AsRef<str> for ExampleKind {- fn as_ref(&self) -> &str {- match self {- Self::All => "all",- Self::DataframeToS3 => "dataframe_to_s3",- Self::QueryAwsS3 => "query_aws_s3",- }- }-}--impl FromStr for ExampleKind {- type Err = DataFusionError;-- fn from_str(s: &str) -> Result<Self> {- match s {- "all" => Ok(Self::All),- "dataframe_to_s3" => Ok(Self::DataframeToS3),- "query_aws_s3" => Ok(Self::QueryAwsS3),- _ => Err(DataFusionError::Execution(format!("Unknown example: {s}"))),- }- }-}-impl ExampleKind {- const ALL_VARIANTS: [Self; 3] = [Self::All, Self::DataframeToS3, Self::QueryAwsS3];-- const RUNNABLE_VARIANTS: [Self; 2] = [Self::DataframeToS3, Self::QueryAwsS3];-const EXAMPLE_NAME: &str = "external_dependency";- fn variants() -> Vec<&'static str> {- Self::ALL_VARIANTS- .iter()- .map(|example| example.as_ref())- .collect()+ fn runnable() -> impl Iterator<Item = ExampleKind> {+ ExampleKind::iter().filter(|v| !matches!(v, ExampleKind::All))}async fn run(&self) -> Result<()> {match self {ExampleKind::All => {- for example in ExampleKind::RUNNABLE_VARIANTS {- println!("Running example: {}", example.as_ref());+ for example in ExampleKind::runnable() {+ println!("Running example: {example}");Box::pin(example.run()).await?;}}@@ -99,14 +71,14 @@ async fn main() -> Result<()> {let usage = format!("Usage: cargo run --example {} -- [{}]",ExampleKind::EXAMPLE_NAME,- ExampleKind::variants().join("|")+ ExampleKind::VARIANTS.join("|"));- let arg = std::env::args().nth(1).ok_or_else(|| {- eprintln!("{usage}");- DataFusionError::Execution("Missing argument".to_string())- })?;+ let example: ExampleKind = std::env::args()+ .nth(1)+ .ok_or_else(|| DataFusionError::Execution(format!("Missing argument. {usage}")))?+ .parse()+ .map_err(|_| DataFusionError::Execution(format!("Unknown example. {usage}")))?;- let example = arg.parse::<ExampleKind>()?;example.run().await}diff --git a/datafusion-examples/examples/flight/main.rs b/datafusion-examples/examples/flight/main.rsindex d2616023a8..25965a3011 100644--- a/datafusion-examples/examples/flight/main.rs+++ b/datafusion-examples/examples/flight/main.rs@@ -37,14 +37,16 @@ mod client;mod server;mod sql_server;-use std::str::FromStr;-use datafusion::error::{DataFusionError, Result};+use strum::{IntoEnumIterator, VariantNames};+use strum_macros::{Display, EnumIter, EnumString, VariantNames};/// The `all` option cannot run all examples end-to-end because the/// `server` example must run in a separate process before the `client`/// example can connect./// Therefore, `all` only iterates over individually runnable examples.+#[derive(EnumIter, EnumString, Display, VariantNames)]+#[strum(serialize_all = "snake_case")]enum ExampleKind {All,Client,@@ -52,51 +54,18 @@ enum ExampleKind {SqlServer,}-impl AsRef<str> for ExampleKind {- fn as_ref(&self) -> &str {- match self {- Self::All => "all",- Self::Client => "client",- Self::Server => "server",- Self::SqlServer => "sql_server",- }- }-}--impl FromStr for ExampleKind {- type Err = DataFusionError;-- fn from_str(s: &str) -> Result<Self> {- match s {- "all" => Ok(Self::All),- "client" => Ok(Self::Client),- "server" => Ok(Self::Server),- "sql_server" => Ok(Self::SqlServer),- _ => Err(DataFusionError::Execution(format!("Unknown example: {s}"))),- }- }-}-impl ExampleKind {- const ALL_VARIANTS: [Self; 4] =- [Self::All, Self::Client, Self::Server, Self::SqlServer];-- const RUNNABLE_VARIANTS: [Self; 3] = [Self::Client, Self::Server, Self::SqlServer];-const EXAMPLE_NAME: &str = "flight";- fn variants() -> Vec<&'static str> {- Self::ALL_VARIANTS- .iter()- .map(|example| example.as_ref())- .collect()+ fn runnable() -> impl Iterator<Item = ExampleKind> {+ ExampleKind::iter().filter(|v| !matches!(v, ExampleKind::All))}async fn run(&self) -> Result<(), Box<dyn std::error::Error>> {match self {ExampleKind::All => {- for example in ExampleKind::RUNNABLE_VARIANTS {- println!("Running example: {}", example.as_ref());+ for example in ExampleKind::runnable() {+ println!("Running example: {example}");Box::pin(example.run()).await?;}}@@ -113,14 +82,14 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {let usage = format!("Usage: cargo run --example {} -- [{}]",ExampleKind::EXAMPLE_NAME,- ExampleKind::variants().join("|")+ ExampleKind::VARIANTS.join("|"));- let arg = std::env::args().nth(1).ok_or_else(|| {- eprintln!("{usage}");- DataFusionError::Execution("Missing argument".to_string())- })?;+ let example: ExampleKind = std::env::args()+ .nth(1)+ .ok_or_else(|| DataFusionError::Execution(format!("Missing argument. {usage}")))?+ .parse()+ .map_err(|_| DataFusionError::Execution(format!("Unknown example. {usage}")))?;- let example = arg.parse::<ExampleKind>()?;example.run().await}diff --git a/datafusion-examples/examples/proto/main.rs b/datafusion-examples/examples/proto/main.rsindex c1ca3e53c0..9e4ae72820 100644--- a/datafusion-examples/examples/proto/main.rs+++ b/datafusion-examples/examples/proto/main.rs@@ -30,55 +30,29 @@mod composed_extension_codec;-use std::str::FromStr;-use datafusion::error::{DataFusionError, Result};+use strum::{IntoEnumIterator, VariantNames};+use strum_macros::{Display, EnumIter, EnumString, VariantNames};+#[derive(EnumIter, EnumString, Display, VariantNames)]+#[strum(serialize_all = "snake_case")]enum ExampleKind {All,ComposedExtensionCodec,}-impl AsRef<str> for ExampleKind {- fn as_ref(&self) -> &str {- match self {- Self::All => "all",- Self::ComposedExtensionCodec => "composed_extension_codec",- }- }-}--impl FromStr for ExampleKind {- type Err = DataFusionError;-- fn from_str(s: &str) -> Result<Self> {- match s {- "all" => Ok(Self::All),- "composed_extension_codec" => Ok(Self::ComposedExtensionCodec),- _ => Err(DataFusionError::Execution(format!("Unknown example: {s}"))),- }- }-}-impl ExampleKind {- const ALL_VARIANTS: [Self; 2] = [Self::All, Self::ComposedExtensionCodec];-- const RUNNABLE_VARIANTS: [Self; 1] = [Self::ComposedExtensionCodec];-const EXAMPLE_NAME: &str = "proto";- fn variants() -> Vec<&'static str> {- Self::ALL_VARIANTS- .iter()- .map(|example| example.as_ref())- .collect()+ fn runnable() -> impl Iterator<Item = ExampleKind> {+ ExampleKind::iter().filter(|v| !matches!(v, ExampleKind::All))}async fn run(&self) -> Result<()> {match self {ExampleKind::All => {- for example in ExampleKind::RUNNABLE_VARIANTS {- println!("Running example: {}", example.as_ref());+ for example in ExampleKind::runnable() {+ println!("Running example: {example}");Box::pin(example.run()).await?;}}@@ -95,14 +69,14 @@ async fn main() -> Result<()> {let usage = format!("Usage: cargo run --example {} -- [{}]",ExampleKind::EXAMPLE_NAME,- ExampleKind::variants().join("|")+ ExampleKind::VARIANTS.join("|"));- let arg = std::env::args().nth(1).ok_or_else(|| {- eprintln!("{usage}");- DataFusionError::Execution("Missing argument".to_string())- })?;+ let example: ExampleKind = std::env::args()+ .nth(1)+ .ok_or_else(|| DataFusionError::Execution(format!("Missing argument. {usage}")))?+ .parse()+ .map_err(|_| DataFusionError::Execution(format!("Unknown example. {usage}")))?;- let example = arg.parse::<ExampleKind>()?;example.run().await}diff --git a/datafusion-examples/examples/query_planning/main.rs b/datafusion-examples/examples/query_planning/main.rsindex 17409f0312..247f468735 100644--- a/datafusion-examples/examples/query_planning/main.rs+++ b/datafusion-examples/examples/query_planning/main.rs@@ -44,10 +44,12 @@ mod planner_api;mod pruning;mod thread_pools;-use std::str::FromStr;-use datafusion::error::{DataFusionError, Result};+use strum::{IntoEnumIterator, VariantNames};+use strum_macros::{Display, EnumIter, EnumString, VariantNames};+#[derive(EnumIter, EnumString, Display, VariantNames)]+#[strum(serialize_all = "snake_case")]enum ExampleKind {All,AnalyzerRule,@@ -60,79 +62,18 @@ enum ExampleKind {ThreadPools,}-impl AsRef<str> for ExampleKind {- fn as_ref(&self) -> &str {- match self {- Self::All => "all",- Self::AnalyzerRule => "analyzer_rule",- Self::ExprApi => "expr_api",- Self::OptimizerRule => "optimizer_rule",- Self::ParseSqlExpr => "parse_sql_expr",- Self::PlanToSql => "plan_to_sql",- Self::PlannerApi => "planner_api",- Self::Pruning => "pruning",- Self::ThreadPools => "thread_pools",- }- }-}--impl FromStr for ExampleKind {- type Err = DataFusionError;-- fn from_str(s: &str) -> Result<Self> {- match s {- "all" => Ok(Self::All),- "analyzer_rule" => Ok(Self::AnalyzerRule),- "expr_api" => Ok(Self::ExprApi),- "optimizer_rule" => Ok(Self::OptimizerRule),- "parse_sql_expr" => Ok(Self::ParseSqlExpr),- "plan_to_sql" => Ok(Self::PlanToSql),- "planner_api" => Ok(Self::PlannerApi),- "pruning" => Ok(Self::Pruning),- "thread_pools" => Ok(Self::ThreadPools),- _ => Err(DataFusionError::Execution(format!("Unknown example: {s}"))),- }- }-}-impl ExampleKind {- const ALL_VARIANTS: [Self; 9] = [- Self::All,- Self::AnalyzerRule,- Self::ExprApi,- Self::OptimizerRule,- Self::ParseSqlExpr,- Self::PlanToSql,- Self::PlannerApi,- Self::Pruning,- Self::ThreadPools,- ];-- const RUNNABLE_VARIANTS: [Self; 8] = [- Self::AnalyzerRule,- Self::ExprApi,- Self::OptimizerRule,- Self::ParseSqlExpr,- Self::PlanToSql,- Self::PlannerApi,- Self::Pruning,- Self::ThreadPools,- ];-const EXAMPLE_NAME: &str = "query_planning";- fn variants() -> Vec<&'static str> {- Self::ALL_VARIANTS- .iter()- .map(|example| example.as_ref())- .collect()+ fn runnable() -> impl Iterator<Item = ExampleKind> {+ ExampleKind::iter().filter(|v| !matches!(v, ExampleKind::All))}async fn run(&self) -> Result<()> {match self {ExampleKind::All => {- for example in ExampleKind::RUNNABLE_VARIANTS {- println!("Running example: {}", example.as_ref());+ for example in ExampleKind::runnable() {+ println!("Running example: {example}");Box::pin(example.run()).await?;}}@@ -154,14 +95,14 @@ async fn main() -> Result<()> {let usage = format!("Usage: cargo run --example {} -- [{}]",ExampleKind::EXAMPLE_NAME,- ExampleKind::variants().join("|")+ ExampleKind::VARIANTS.join("|"));- let arg = std::env::args().nth(1).ok_or_else(|| {- eprintln!("{usage}");- DataFusionError::Execution("Missing argument".to_string())- })?;+ let example: ExampleKind = std::env::args()+ .nth(1)+ .ok_or_else(|| DataFusionError::Execution(format!("Missing argument. {usage}")))?+ .parse()+ .map_err(|_| DataFusionError::Execution(format!("Unknown example. {usage}")))?;- let example = arg.parse::<ExampleKind>()?;example.run().await}diff --git a/datafusion-examples/examples/relation_planner/main.rs b/datafusion-examples/examples/relation_planner/main.rsindex ff9c93de7b..d2ba2202d1 100644--- a/datafusion-examples/examples/relation_planner/main.rs+++ b/datafusion-examples/examples/relation_planner/main.rs@@ -22,10 +22,11 @@//!//! ## Usage//! ```bash-//! cargo run --example relation_planner -- [match_recognize|pivot_unpivot|table_sample]+//! cargo run --example relation_planner -- [all|match_recognize|pivot_unpivot|table_sample]//! ```//!//! Each subcommand runs a corresponding example:+//! - `all` — run all examples included in this module//! - `match_recognize` — MATCH_RECOGNIZE pattern matching on event streams//! - `pivot_unpivot` — PIVOT and UNPIVOT operations for reshaping data//! - `table_sample` — TABLESAMPLE clause for sampling rows from tables@@ -42,46 +43,40 @@ mod match_recognize;mod pivot_unpivot;mod table_sample;-use std::str::FromStr;-use datafusion::error::{DataFusionError, Result};+use strum::{IntoEnumIterator, VariantNames};+use strum_macros::{Display, EnumIter, EnumString, VariantNames};+#[derive(EnumIter, EnumString, Display, VariantNames)]+#[strum(serialize_all = "snake_case")]enum ExampleKind {+ All,MatchRecognize,PivotUnpivot,TableSample,}-impl AsRef<str> for ExampleKind {- fn as_ref(&self) -> &str {- match self {- Self::MatchRecognize => "match_recognize",- Self::PivotUnpivot => "pivot_unpivot",- Self::TableSample => "table_sample",- }- }-}--impl FromStr for ExampleKind {- type Err = DataFusionError;+impl ExampleKind {+ const EXAMPLE_NAME: &str = "relation_planner";- fn from_str(s: &str) -> Result<Self> {- match s {- "match_recognize" => Ok(Self::MatchRecognize),- "pivot_unpivot" => Ok(Self::PivotUnpivot),- "table_sample" => Ok(Self::TableSample),- _ => Err(DataFusionError::Execution(format!("Unknown example: {s}"))),- }+ fn runnable() -> impl Iterator<Item = ExampleKind> {+ ExampleKind::iter().filter(|v| !matches!(v, ExampleKind::All))}-}-impl ExampleKind {- const ALL: [Self; 3] = [Self::MatchRecognize, Self::PivotUnpivot, Self::TableSample];-- const EXAMPLE_NAME: &str = "relation_planner";+ async fn run(&self) -> Result<()> {+ match self {+ ExampleKind::All => {+ for example in ExampleKind::runnable() {+ println!("Running example: {example}");+ Box::pin(example.run()).await?;+ }+ }+ ExampleKind::MatchRecognize => match_recognize::match_recognize().await?,+ ExampleKind::PivotUnpivot => pivot_unpivot::pivot_unpivot().await?,+ ExampleKind::TableSample => table_sample::table_sample().await?,+ }- fn variants() -> Vec<&'static str> {- Self::ALL.iter().map(|x| x.as_ref()).collect()+ Ok(())}}@@ -90,31 +85,16 @@ async fn main() -> Result<()> {let usage = format!("Usage: cargo run --example {} -- [{}]",ExampleKind::EXAMPLE_NAME,- ExampleKind::variants().join("|")+ ExampleKind::VARIANTS.join("|"));- let arg = std::env::args().nth(1).ok_or_else(|| {- eprintln!("{usage}");- DataFusionError::Execution("Missing argument".to_string())- })?;-- if arg == "all" {- for example in ExampleKind::ALL {- match example {- ExampleKind::MatchRecognize => match_recognize::match_recognize().await?,- ExampleKind::PivotUnpivot => pivot_unpivot::pivot_unpivot().await?,- ExampleKind::TableSample => table_sample::table_sample().await?,- }- }- } else {- match arg.parse::<ExampleKind>()? {- ExampleKind::MatchRecognize => match_recognize::match_recognize().await?,- ExampleKind::PivotUnpivot => pivot_unpivot::pivot_unpivot().await?,- ExampleKind::TableSample => table_sample::table_sample().await?,- }- }+ let example: ExampleKind = std::env::args()+ .nth(1)+ .ok_or_else(|| DataFusionError::Execution(format!("Missing argument. {usage}")))?+ .parse()+ .map_err(|_| DataFusionError::Execution(format!("Unknown example. {usage}")))?;- Ok(())+ example.run().await}/// Test wrappers that enable `cargo insta test --example relation_planner --accept`diff --git a/datafusion-examples/examples/sql_ops/main.rs b/datafusion-examples/examples/sql_ops/main.rsindex 154972aa74..63074e0360 100644--- a/datafusion-examples/examples/sql_ops/main.rs+++ b/datafusion-examples/examples/sql_ops/main.rs@@ -36,10 +36,12 @@ mod dialect;mod frontend;mod query;-use std::str::FromStr;-use datafusion::error::{DataFusionError, Result};+use strum::{IntoEnumIterator, VariantNames};+use strum_macros::{Display, EnumIter, EnumString, VariantNames};+#[derive(EnumIter, EnumString, Display, VariantNames)]+#[strum(serialize_all = "snake_case")]enum ExampleKind {All,Analysis,@@ -48,59 +50,18 @@ enum ExampleKind {Query,}-impl AsRef<str> for ExampleKind {- fn as_ref(&self) -> &str {- match self {- Self::All => "all",- Self::Analysis => "analysis",- Self::Dialect => "dialect",- Self::Frontend => "frontend",- Self::Query => "query",- }- }-}--impl FromStr for ExampleKind {- type Err = DataFusionError;-- fn from_str(s: &str) -> Result<Self> {- match s {- "all" => Ok(Self::All),- "analysis" => Ok(Self::Analysis),- "dialect" => Ok(Self::Dialect),- "frontend" => Ok(Self::Frontend),- "query" => Ok(Self::Query),- _ => Err(DataFusionError::Execution(format!("Unknown example: {s}"))),- }- }-}-impl ExampleKind {- const ALL_VARIANTS: [Self; 5] = [- Self::All,- Self::Analysis,- Self::Dialect,- Self::Frontend,- Self::Query,- ];-- const RUNNABLE_VARIANTS: [Self; 4] =- [Self::Analysis, Self::Dialect, Self::Frontend, Self::Query];-const EXAMPLE_NAME: &str = "sql_ops";- fn variants() -> Vec<&'static str> {- Self::ALL_VARIANTS- .iter()- .map(|example| example.as_ref())- .collect()+ fn runnable() -> impl Iterator<Item = ExampleKind> {+ ExampleKind::iter().filter(|v| !matches!(v, ExampleKind::All))}async fn run(&self) -> Result<()> {match self {ExampleKind::All => {- for example in ExampleKind::RUNNABLE_VARIANTS {- println!("Running example: {}", example.as_ref());+ for example in ExampleKind::runnable() {+ println!("Running example: {example}");Box::pin(example.run()).await?;}}@@ -118,14 +79,14 @@ async fn main() -> Result<()> {let usage = format!("Usage: cargo run --example {} -- [{}]",ExampleKind::EXAMPLE_NAME,- ExampleKind::variants().join("|")+ ExampleKind::VARIANTS.join("|"));- let arg = std::env::args().nth(1).ok_or_else(|| {- eprintln!("{usage}");- DataFusionError::Execution("Missing argument".to_string())- })?;+ let example: ExampleKind = std::env::args()+ .nth(1)+ .ok_or_else(|| DataFusionError::Execution(format!("Missing argument. {usage}")))?+ .parse()+ .map_err(|_| DataFusionError::Execution(format!("Unknown example. {usage}")))?;- let example = arg.parse::<ExampleKind>()?;example.run().await}diff --git a/datafusion-examples/examples/udf/main.rs b/datafusion-examples/examples/udf/main.rsindex 34bd34ab25..0fb26ff5f7 100644--- a/datafusion-examples/examples/udf/main.rs+++ b/datafusion-examples/examples/udf/main.rs@@ -44,10 +44,12 @@ mod simple_udf;mod simple_udtf;mod simple_udwf;-use std::str::FromStr;-use datafusion::error::{DataFusionError, Result};+use strum::{IntoEnumIterator, VariantNames};+use strum_macros::{Display, EnumIter, EnumString, VariantNames};+#[derive(EnumIter, EnumString, Display, VariantNames)]+#[strum(serialize_all = "snake_case")]enum ExampleKind {All,AdvUdaf,@@ -60,79 +62,18 @@ enum ExampleKind {Udtf,}-impl AsRef<str> for ExampleKind {- fn as_ref(&self) -> &str {- match self {- Self::All => "all",- Self::AdvUdaf => "adv_udaf",- Self::AdvUdf => "adv_udf",- Self::AdvUdwf => "adv_udwf",- Self::AsyncUdf => "async_udf",- Self::Udf => "udf",- Self::Udaf => "udaf",- Self::Udwf => "udwf",- Self::Udtf => "udtf",- }- }-}--impl FromStr for ExampleKind {- type Err = DataFusionError;-- fn from_str(s: &str) -> Result<Self> {- match s {- "all" => Ok(Self::All),- "adv_udaf" => Ok(Self::AdvUdaf),- "adv_udf" => Ok(Self::AdvUdf),- "adv_udwf" => Ok(Self::AdvUdwf),- "async_udf" => Ok(Self::AsyncUdf),- "udaf" => Ok(Self::Udaf),- "udf" => Ok(Self::Udf),- "udtf" => Ok(Self::Udtf),- "udwf" => Ok(Self::Udwf),- _ => Err(DataFusionError::Execution(format!("Unknown example: {s}"))),- }- }-}-impl ExampleKind {- const ALL_VARIANTS: [Self; 9] = [- Self::All,- Self::AdvUdaf,- Self::AdvUdf,- Self::AdvUdwf,- Self::AsyncUdf,- Self::Udaf,- Self::Udf,- Self::Udtf,- Self::Udwf,- ];-- const RUNNABLE_VARIANTS: [Self; 8] = [- Self::AdvUdaf,- Self::AdvUdf,- Self::AdvUdwf,- Self::AsyncUdf,- Self::Udaf,- Self::Udf,- Self::Udtf,- Self::Udwf,- ];-const EXAMPLE_NAME: &str = "udf";- fn variants() -> Vec<&'static str> {- Self::ALL_VARIANTS- .iter()- .map(|example| example.as_ref())- .collect()+ fn runnable() -> impl Iterator<Item = ExampleKind> {+ ExampleKind::iter().filter(|v| !matches!(v, ExampleKind::All))}async fn run(&self) -> Result<()> {match self {ExampleKind::All => {- for example in ExampleKind::RUNNABLE_VARIANTS {- println!("Running example: {}", example.as_ref());+ for example in ExampleKind::runnable() {+ println!("Running example: {example}");Box::pin(example.run()).await?;}}@@ -155,14 +96,14 @@ async fn main() -> Result<()> {let usage = format!("Usage: cargo run --example {} -- [{}]",ExampleKind::EXAMPLE_NAME,- ExampleKind::variants().join("|")+ ExampleKind::VARIANTS.join("|"));- let arg = std::env::args().nth(1).ok_or_else(|| {- eprintln!("{usage}");- DataFusionError::Execution("Missing argument".to_string())- })?;+ let example: ExampleKind = std::env::args()+ .nth(1)+ .ok_or_else(|| DataFusionError::Execution(format!("Missing argument. {usage}")))?+ .parse()+ .map_err(|_| DataFusionError::Execution(format!("Unknown example. {usage}")))?;- let example = arg.parse::<ExampleKind>()?;example.run().await}