Skip to content

Apache DataFusion SQL Query Engine

Use strum in the examples (#19126) (#19205)

Sergey Zhukovdc6a71235b3d
diff --git a/Cargo.lock b/Cargo.lock
index 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.toml
index 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.toml
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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
}