Derive Debug for SessionStateBuilder, adding Debug requirements to fields (#12632)

* Require Debug for PhysicalOptimizerRule

* Add reference to meet &JoinType type required

* Revert "Add reference to meet &JoinType type required" as clippy lint informs this is unnecessary

This reverts commit f69d73c.

* Require `Debug` for `CatalogProvider`, `CatalogProviderList`, UrlTableFactory

* Add derive Debug to meet api-change

* Add derive Debug in datafusion-cli to support api-change of CatalogProviderList

* Require Debug for ExprPlanner

* Require Debug for QueryPlanner

* Require Debug for TableFunctionImpl

* Require Debug for SerializerRegistry

* Require Debug for FunctionFactory

* Derive `Debug` on `SessionStateBuilder`

* Implement `Debug` for `SessionStateBuilder` to reorder output fields, keep consistent Debug field order with `SessionState`

* Settle TODO for displaying `Debug` of `InformationSchemaConfig` after `CatalogProviderList` requires `Debug`

Author: AnthonyZhOon

datafusion-cli/src/catalog.rs

@@ -34,6 +34,7 @@ use dirs::home_dir;
 use parking_lot::RwLock;
 
 /// Wraps another catalog, automatically register require object stores for the file locations
+#[derive(Debug)]
 pub struct DynamicObjectStoreCatalog {
     inner: Arc<dyn CatalogProviderList>,
     state: Weak<RwLock<SessionState>>,
@@ -74,6 +75,7 @@ impl CatalogProviderList for DynamicObjectStoreCatalog {
 }
 
 /// Wraps another catalog provider
+#[derive(Debug)]
 struct DynamicObjectStoreCatalogProvider {
     inner: Arc<dyn CatalogProvider>,
     state: Weak<RwLock<SessionState>>,
@@ -115,6 +117,7 @@ impl CatalogProvider for DynamicObjectStoreCatalogProvider {
 
 /// Wraps another schema provider. [DynamicObjectStoreSchemaProvider] is responsible for registering the required
 /// object stores for the file locations.
+#[derive(Debug)]
 struct DynamicObjectStoreSchemaProvider {
     inner: Arc<dyn SchemaProvider>,
     state: Weak<RwLock<SessionState>>,

datafusion-cli/src/functions.rs

@@ -315,6 +315,7 @@ fn fixed_len_byte_array_to_string(val: Option<&FixedLenByteArray>) -> Option<Str
     })
 }
 
+#[derive(Debug)]
 pub struct ParquetMetadataFunc {}
 
 impl TableFunctionImpl for ParquetMetadataFunc {

datafusion-examples/examples/catalog.rs

@@ -135,6 +135,7 @@ struct DirSchemaOpts<'a> {
     format: Arc<dyn FileFormat>,
 }
 /// Schema where every file with extension `ext` in a given `dir` is a table.
+#[derive(Debug)]
 struct DirSchema {
     ext: String,
     tables: RwLock<HashMap<String, Arc<dyn TableProvider>>>,
@@ -218,6 +219,7 @@ impl SchemaProvider for DirSchema {
     }
 }
 /// Catalog holds multiple schemas
+#[derive(Debug)]
 struct DirCatalog {
     schemas: RwLock<HashMap<String, Arc<dyn SchemaProvider>>>,
 }
@@ -259,6 +261,7 @@ impl CatalogProvider for DirCatalog {
     }
 }
 /// Catalog lists holds multiple catalog providers. Each context has a single catalog list.
+#[derive(Debug)]
 struct CustomCatalogProviderList {
     catalogs: RwLock<HashMap<String, Arc<dyn CatalogProvider>>>,
 }

datafusion-examples/examples/simple_udtf.rs

@@ -128,6 +128,7 @@ impl TableProvider for LocalCsvTable {
     }
 }
 
+#[derive(Debug)]
 struct LocalCsvTableFunc {}
 
 impl TableFunctionImpl for LocalCsvTableFunc {

datafusion/catalog/src/catalog.rs

@@ -16,6 +16,7 @@
 // under the License.
 
 use std::any::Any;
+use std::fmt::Debug;
 use std::sync::Arc;
 
 pub use crate::schema::SchemaProvider;
@@ -101,7 +102,7 @@ use datafusion_common::Result;
 ///
 /// [`TableProvider`]: crate::TableProvider
 
-pub trait CatalogProvider: Sync + Send {
+pub trait CatalogProvider: Debug + Sync + Send {
     /// Returns the catalog provider as [`Any`]
     /// so that it can be downcast to a specific implementation.
     fn as_any(&self) -> &dyn Any;
@@ -152,7 +153,7 @@ pub trait CatalogProvider: Sync + Send {
 ///
 /// Please see the documentation on `CatalogProvider` for details of
 /// implementing a custom catalog.
-pub trait CatalogProviderList: Sync + Send {
+pub trait CatalogProviderList: Debug + Sync + Send {
     /// Returns the catalog list as [`Any`]
     /// so that it can be downcast to a specific implementation.
     fn as_any(&self) -> &dyn Any;

datafusion/catalog/src/dynamic_file/catalog.rs

@@ -20,9 +20,11 @@
 use crate::{CatalogProvider, CatalogProviderList, SchemaProvider, TableProvider};
 use async_trait::async_trait;
 use std::any::Any;
+use std::fmt::Debug;
 use std::sync::Arc;
 
 /// Wrap another catalog provider list
+#[derive(Debug)]
 pub struct DynamicFileCatalog {
     /// The inner catalog provider list
     inner: Arc<dyn CatalogProviderList>,
@@ -67,6 +69,7 @@ impl CatalogProviderList for DynamicFileCatalog {
 }
 
 /// Wraps another catalog provider
+#[derive(Debug)]
 struct DynamicFileCatalogProvider {
     /// The inner catalog provider
     inner: Arc<dyn CatalogProvider>,
@@ -114,6 +117,7 @@ impl CatalogProvider for DynamicFileCatalogProvider {
 ///
 /// The provider will try to create a table provider from the file path if the table provider
 /// isn't exist in the inner schema provider.
+#[derive(Debug)]
 pub struct DynamicFileSchemaProvider {
     /// The inner schema provider
     inner: Arc<dyn SchemaProvider>,
@@ -174,7 +178,7 @@ impl SchemaProvider for DynamicFileSchemaProvider {
 
 /// [UrlTableFactory] is a factory that can create a table provider from the given url.
 #[async_trait]
-pub trait UrlTableFactory: Sync + Send {
+pub trait UrlTableFactory: Debug + Sync + Send {
     /// create a new table provider from the provided url
     async fn try_new(
         &self,

datafusion/catalog/src/schema.rs

@@ -21,6 +21,7 @@
 use async_trait::async_trait;
 use datafusion_common::{exec_err, DataFusionError};
 use std::any::Any;
+use std::fmt::Debug;
 use std::sync::Arc;
 
 use crate::table::TableProvider;
@@ -32,7 +33,7 @@ use datafusion_common::Result;
 ///
 /// [`CatalogProvider`]: super::CatalogProvider
 #[async_trait]
-pub trait SchemaProvider: Sync + Send {
+pub trait SchemaProvider: Debug + Sync + Send {
     /// Returns the owner of the Schema, default is None. This value is reported
     /// as part of `information_tables.schemata
     fn owner_name(&self) -> Option<&str> {

datafusion/catalog/src/session.rs

@@ -139,6 +139,7 @@ impl From<&dyn Session> for TaskContext {
 }
 type SessionRefLock = Arc<Mutex<Option<Weak<RwLock<dyn Session>>>>>;
 /// The state store that stores the reference of the runtime session state.
+#[derive(Debug)]
 pub struct SessionStore {
     session: SessionRefLock,
 }

datafusion/core/src/catalog_common/information_schema.rs

@@ -26,7 +26,7 @@ use arrow::{
 };
 use async_trait::async_trait;
 use datafusion_common::DataFusionError;
-use std::fmt::{Debug, Formatter};
+use std::fmt::Debug;
 use std::{any::Any, sync::Arc};
 
 use crate::catalog::{CatalogProviderList, SchemaProvider, TableProvider};
@@ -57,6 +57,7 @@ pub const INFORMATION_SCHEMA_TABLES: &[&str] =
 /// demand. This means that if more tables are added to the underlying
 /// providers, they will appear the next time the `information_schema`
 /// table is queried.
+#[derive(Debug)]
 pub struct InformationSchemaProvider {
     config: InformationSchemaConfig,
 }
@@ -70,20 +71,11 @@ impl InformationSchemaProvider {
     }
 }
 
-#[derive(Clone)]
+#[derive(Clone, Debug)]
 struct InformationSchemaConfig {
     catalog_list: Arc<dyn CatalogProviderList>,
 }
 
-impl Debug for InformationSchemaConfig {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct("InformationSchemaConfig")
-            // TODO it would be great to print the catalog list here
-            // but that would require CatalogProviderList to implement Debug
-            .finish_non_exhaustive()
-    }
-}
-
 impl InformationSchemaConfig {
     /// Construct the `information_schema.tables` virtual table
     async fn make_tables(

datafusion/core/src/catalog_common/listing_schema.rs

@@ -48,6 +48,7 @@ use object_store::ObjectStore;
 /// - `s3://host.example.com:3000/data/tpch/customer/_delta_log/`
 ///
 /// [`ObjectStore`]: object_store::ObjectStore
+#[derive(Debug)]
 pub struct ListingSchemaProvider {
     authority: String,
     path: object_store::path::Path,