refactor: update ParserOptions to use default method for initialization

Author: kosiew

datafusion/sql/src/planner.rs

@@ -43,15 +43,10 @@ pub use datafusion_expr::planner::ContextProvider;
 /// SQL parser options
 #[derive(Debug, Clone, Copy)]
 pub struct ParserOptions {
-    /// If true, parse float as decimal
     pub parse_float_as_decimal: bool,
-    /// If true, normalize identifiers
     pub enable_ident_normalization: bool,
-    /// If true, support varchar with length
     pub support_varchar_with_length: bool,
-    /// If true, normalize option values
     pub enable_options_value_normalization: bool,
-    /// If true, collect spans during parsing
     pub collect_spans: bool,
 }
 
@@ -61,7 +56,7 @@ impl ParserOptions {
     /// # Examples
     ///
     /// ```
-    /// use datafusion::sql::planner::ParserOptions;
+    /// use datafusion_sql::planner::ParserOptions;
     /// let opts = ParserOptions::new();
     /// assert_eq!(opts.parse_float_as_decimal(), false);
     /// assert_eq!(opts.enable_ident_normalization(), true);
@@ -81,7 +76,7 @@ impl ParserOptions {
     /// # Examples
     ///
     /// ```
-    /// use datafusion::sql::planner::ParserOptions;
+    /// use datafusion_sql::planner::ParserOptions;
     /// let opts = ParserOptions::new().with_parse_float_as_decimal(true);
     /// assert_eq!(opts.parse_float_as_decimal(), true);
     /// ```
@@ -95,7 +90,7 @@ impl ParserOptions {
     /// # Examples
     ///
     /// ```
-    /// use datafusion::sql::planner::ParserOptions;
+    /// use datafusion_sql::planner::ParserOptions;
     /// let opts = ParserOptions::new().with_enable_ident_normalization(false);
     /// assert_eq!(opts.enable_ident_normalization(), false);
     /// ```
@@ -148,6 +143,12 @@ impl ParserOptions {
     }
 }
 
+impl Default for ParserOptions {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 /// Ident Normalizer
 #[derive(Debug)]
 pub struct IdentNormalizer {
@@ -337,7 +338,7 @@ pub struct SqlToRel<'a, S: ContextProvider> {
 impl<'a, S: ContextProvider> SqlToRel<'a, S> {
     /// Create a new query planner
     pub fn new(context_provider: &'a S) -> Self {
-        Self::new_with_options(context_provider, ParserOptions::new())
+        Self::new_with_options(context_provider, ParserOptions::default())
     }
 
     /// Create a new query planner

datafusion/sql/tests/cases/diagnostic.rs

@@ -33,7 +33,7 @@ fn do_query(sql: &'static str) -> Diagnostic {
         .expect("unable to parse query");
     let options = ParserOptions {
         collect_spans: true,
-        ..ParserOptions::new()
+        ..ParserOptions::default()
     };
 
     let state = MockSessionState::default();

datafusion/sql/tests/sql_integration.rs

@@ -1434,7 +1434,7 @@ fn recursive_ctes_disabled() {
     state.config_options.execution.enable_recursive_ctes = false;
     let context = MockContextProvider { state };
 
-    let planner = SqlToRel::new_with_options(&context, ParserOptions::new());
+    let planner = SqlToRel::new_with_options(&context, ParserOptions::default());
     let result = DFParser::parse_sql_with_dialect(sql, &GenericDialect {});
     let mut ast = result.unwrap();
 
@@ -2593,7 +2593,7 @@ fn select_groupby_orderby() {
 }
 
 fn logical_plan(sql: &str) -> Result<LogicalPlan> {
-    logical_plan_with_options(sql, ParserOptions::new())
+    logical_plan_with_options(sql, ParserOptions::default())
 }
 
 fn logical_plan_with_options(sql: &str, options: ParserOptions) -> Result<LogicalPlan> {
@@ -2702,7 +2702,7 @@ impl ScalarUDFImpl for DummyUDF {
 
 /// Create logical plan, write with formatter, compare to expected output
 fn quick_test(sql: &str, expected: &str) {
-    quick_test_with_options(sql, expected, ParserOptions::new())
+    quick_test_with_options(sql, expected, ParserOptions::default())
 }
 
 fn quick_test_with_options(sql: &str, expected: &str, options: ParserOptions) {
@@ -4453,7 +4453,7 @@ fn test_parse_escaped_string_literal_value() {
 fn plan_create_index() {
     let sql =
         "CREATE UNIQUE INDEX IF NOT EXISTS idx_name ON test USING btree (name, age DESC)";
-    let plan = logical_plan_with_options(sql, ParserOptions::new()).unwrap();
+    let plan = logical_plan_with_options(sql, ParserOptions::default()).unwrap();
     match plan {
         LogicalPlan::Ddl(DdlStatement::CreateIndex(CreateIndex {
             name,
@@ -4513,7 +4513,7 @@ fn init() {
 fn test_no_functions_registered() {
     let sql = "SELECT foo()";
 
-    let options = ParserOptions::new();
+    let options = ParserOptions::default();
     let dialect = &GenericDialect {};
     let state = MockSessionState::default();
     let context = MockContextProvider { state };
@@ -4534,7 +4534,7 @@ fn test_custom_type_plan() -> Result<()> {
     let sql = "SELECT DATETIME '2001-01-01 18:00:00'";
 
     // test the default behavior
-    let options = ParserOptions::new();
+    let options = ParserOptions::default();
     let dialect = &GenericDialect {};
     let state = MockSessionState::default();
     let context = MockContextProvider { state };
@@ -4548,7 +4548,7 @@ fn test_custom_type_plan() -> Result<()> {
     );
 
     fn plan_sql(sql: &str) -> LogicalPlan {
-        let options = ParserOptions::new();
+        let options = ParserOptions::default();
         let dialect = &GenericDialect {};
         let state = MockSessionState::default()
             .with_scalar_function(make_array_udf())