Fix the parsing result for the special double number

src/dialect/bigquery.rs

@@ -77,4 +77,8 @@ impl Dialect for BigQueryDialect {
     fn supports_struct_literal(&self) -> bool {
         true
     }
+
+    fn support_unquoted_hyphenated_identifiers(&self) -> bool {
+        true
+    }
 }

src/dialect/mod.rs

@@ -762,6 +762,15 @@ pub trait Dialect: Debug + Any {
     fn supports_table_sample_before_alias(&self) -> bool {
         false
     }
+
+    /// Returns true if the dialect supports unquoted hyphenated identifiers
+    ///
+    /// For example, BigQuery supports the following identifier:
+    ///     `SELECT * FROM my-project.my_dataset.my_table`
+    /// The project name `my-project` is a hyphenated identifier.
+    fn support_unquoted_hyphenated_identifiers(&self) -> bool {
+        false
+    }
 }
 
 /// This represents the operators for which precedence must be defined

src/parser/mod.rs

@@ -978,13 +978,6 @@ impl<'a> Parser<'a> {
         let _guard = self.recursion_counter.try_decrease()?;
         debug!("parsing expr");
         let mut expr = self.parse_prefix()?;
-        // Attempt to parse composite access. Example `SELECT f(x).a`
-        while self.consume_token(&Token::Period) {
-            expr = Expr::CompositeAccess {
-                expr: Box::new(expr),
-                key: self.parse_identifier(false)?,
-            }
-        }
 
         debug!("prefix: {:?}", expr);
         loop {
@@ -1150,7 +1143,8 @@ impl<'a> Parser<'a> {
                 Ok(Some(self.parse_match_against()?))
             }
             Keyword::STRUCT if self.dialect.supports_struct_literal() => {
-                Ok(Some(self.parse_struct_literal()?))
+                let struct_expr = self.parse_struct_literal()?;
+                Ok(Some(self.parse_compound_field_access(struct_expr, vec![])?))
             }
             Keyword::PRIOR if matches!(self.state, ParserState::ConnectBy) => {
                 let expr = self.parse_subexpr(self.dialect.prec_value(Precedence::PlusMinus))?;
@@ -1397,7 +1391,25 @@ impl<'a> Parser<'a> {
                     }
                 };
                 self.expect_token(&Token::RParen)?;
-                self.try_parse_method(expr)
+                let expr = self.try_parse_method(expr)?;
+                if !self.consume_token(&Token::Period) {
+                    Ok(expr)
+                } else {
+                    let tok = self.next_token();
+                    let key = match tok.token {
+                        Token::Word(word) => word.to_ident(tok.span),
+                        _ => {
+                            return parser_err!(
+                                format!("Expected identifier, found: {tok}"),
+                                tok.span.start
+                            )
+                        }
+                    };
+                    Ok(Expr::CompositeAccess {
+                        expr: Box::new(expr),
+                        key,
+                    })
+                }
             }
             Token::Placeholder(_) | Token::Colon | Token::AtSign => {
                 self.prev_token();

src/tokenizer.rs

@@ -1141,33 +1141,44 @@ impl<'a> Tokenizer<'a> {
                         let s2 = peeking_take_while(chars, |ch| ch.is_ascii_hexdigit());
                         return Ok(Some(Token::HexStringLiteral(s2)));
                     }
-
                     // match one period
-                    if let Some('.') = chars.peek() {
-                        // Check if this actually is a float point number
-                        let mut char_clone = chars.peekable.clone();
-                        char_clone.next();
-                        // Next char should be a digit, otherwise, it is not a float point number
-                        if char_clone
-                            .peek()
-                            .map(|c| c.is_ascii_digit())
-                            .unwrap_or(false)
-                        {
+                    if self.dialect.support_unquoted_hyphenated_identifiers() {
+                        if let Some('.') = chars.peek() {
+                            // Check if this actually is a float point number
+                            let mut char_clone = chars.peekable.clone();
+                            char_clone.next();
+                            // Next char should be a digit, otherwise, it is not a float point number
+                            if char_clone
+                                .peek()
+                                .map(|c| c.is_ascii_digit())
+                                .unwrap_or(false)
+                            {
+                                s.push('.');
+                                chars.next();
+                            } else if !s.is_empty() {
+                                // Number might be part of period separated construct. Keep the period for next token
+                                // e.g. a-12.b
+                                return Ok(Some(Token::Number(s, false)));
+                            } else {
+                                // No number -> Token::Period
+                                chars.next();
+                                return Ok(Some(Token::Period));
+                            }
+                        }
+
+                        s += &peeking_take_while(chars, |ch| ch.is_ascii_digit());
+                    } else {
+                        if let Some('.') = chars.peek() {
                             s.push('.');
                             chars.next();
-                        } else if !s.is_empty() {
-                            // Number might be part of period separated construct. Keep the period for next token
-                            // e.g. a-12.b
-                            return Ok(Some(Token::Number(s, false)));
-                        } else {
-                            // No number -> Token::Period
-                            chars.next();
+                        }
+                        s += &peeking_take_while(chars, |ch| ch.is_ascii_digit());
+
+                        // No number -> Token::Period
+                        if s == "." {
                             return Ok(Some(Token::Period));
                         }
                     }
-
-                    s += &peeking_take_while(chars, |ch| ch.is_ascii_digit());
-
                     let mut exponent_part = String::new();
                     // Parse exponent as number
                     if chars.peek() == Some(&'e') || chars.peek() == Some(&'E') {
@@ -2154,6 +2165,7 @@ mod tests {
         BigQueryDialect, ClickHouseDialect, HiveDialect, MsSqlDialect, MySqlDialect,
     };
     use core::fmt::Debug;
+    use sqlparser::test_utils::all_dialects_where;
 
     #[test]
     fn tokenizer_error_impl() {
@@ -2202,18 +2214,20 @@ mod tests {
     #[test]
     fn tokenize_select_float_hyphenated_identifier() {
         let sql = String::from("SELECT a-12.b");
-        let dialect = GenericDialect {};
-        let tokens = Tokenizer::new(&dialect, &sql).tokenize().unwrap();
-        let expected = vec![
-            Token::make_keyword("SELECT"),
-            Token::Whitespace(Whitespace::Space),
-            Token::make_word("a", None),
-            Token::Minus,
-            Token::Number(String::from("12"), false),
-            Token::Period,
-            Token::make_word("b", None),
-        ];
-        compare(expected, tokens);
+        let dialects = all_dialects_where(|d| d.support_unquoted_hyphenated_identifiers());
+        for dialect in dialects.dialects {
+            let tokens = Tokenizer::new(dialect.as_ref(), &sql).tokenize().unwrap();
+            let expected = vec![
+                Token::make_keyword("SELECT"),
+                Token::Whitespace(Whitespace::Space),
+                Token::make_word("a", None),
+                Token::Minus,
+                Token::Number(String::from("12"), false),
+                Token::Period,
+                Token::make_word("b", None),
+            ];
+            compare(expected, tokens);
+        }
     }
 
     #[test]

tests/sqlparser_common.rs

@@ -2964,6 +2964,115 @@ fn test_compound_expr() {
     }
 }
 
+#[test]
+fn test_double_value() {
+    // TODO: support double value for dialect that supports unquoted hyphenated identifiers
+    // see issue: https://github.com/apache/datafusion-sqlparser-rs/issues/1622
+    let dialects = all_dialects_where(|dialect| !dialect.support_unquoted_hyphenated_identifiers());
+    let test_cases = vec![
+        gen_number_case_with_sign("0."),
+        gen_number_case_with_sign("0.0"),
+        gen_number_case_with_sign("0000."),
+        gen_number_case_with_sign("0000.00"),
+        gen_number_case_with_sign(".0"),
+        gen_number_case_with_sign(".00"),
+        gen_number_case_with_sign("0e0"),
+        gen_number_case_with_sign("0e+0"),
+        gen_number_case_with_sign("0e-0"),
+        gen_number_case_with_sign("0.e-0"),
+        gen_number_case_with_sign("0.e+0"),
+        gen_number_case_with_sign(".0e-0"),
+        gen_number_case_with_sign(".0e+0"),
+        gen_number_case_with_sign("00.0e+0"),
+        gen_number_case_with_sign("00.0e-0"),
+    ];
+
+    for (input, expected) in test_cases {
+        for (i, expr) in input.iter().enumerate() {
+            if let Statement::Query(query) =
+                dialects.one_statement_parses_to(&format!("SELECT {}", expr), "")
+            {
+                if let SetExpr::Select(select) = *query.body {
+                    assert_eq!(expected[i], select.projection[0]);
+                } else {
+                    panic!("Expected a SELECT statement");
+                }
+            } else {
+                panic!("Expected a SELECT statement");
+            }
+        }
+    }
+}
+
+fn gen_number_case(value: &str) -> (Vec<String>, Vec<SelectItem>) {
+    let input = vec![
+        value.to_string(),
+        format!("{} col_alias", value),
+        format!("{} AS col_alias", value),
+    ];
+    let expected = vec![
+        SelectItem::UnnamedExpr(Expr::Value(number(value))),
+        SelectItem::ExprWithAlias {
+            expr: Expr::Value(number(value)),
+            alias: Ident::new("col_alias"),
+        },
+        SelectItem::ExprWithAlias {
+            expr: Expr::Value(number(value)),
+            alias: Ident::new("col_alias"),
+        },
+    ];
+    (input, expected)
+}
+
+fn gen_sign_number_case(value: &str, op: UnaryOperator) -> (Vec<String>, Vec<SelectItem>) {
+    match op {
+        UnaryOperator::Plus | UnaryOperator::Minus => {}
+        _ => panic!("Invalid sign"),
+    }
+
+    let input = vec![
+        format!("{}{}", op, value),
+        format!("{}{} col_alias", op, value),
+        format!("{}{} AS col_alias", op, value),
+    ];
+    let expected = vec![
+        SelectItem::UnnamedExpr(Expr::UnaryOp {
+            op,
+            expr: Box::new(Expr::Value(number(value))),
+        }),
+        SelectItem::ExprWithAlias {
+            expr: Expr::UnaryOp {
+                op,
+                expr: Box::new(Expr::Value(number(value))),
+            },
+            alias: Ident::new("col_alias"),
+        },
+        SelectItem::ExprWithAlias {
+            expr: Expr::UnaryOp {
+                op,
+                expr: Box::new(Expr::Value(number(value))),
+            },
+            alias: Ident::new("col_alias"),
+        },
+    ];
+    (input, expected)
+}
+
+/// generate the test cases for signed and unsigned numbers
+/// For example, given "0.0", the test cases will be:
+/// - "0.0"
+/// - "+0.0"
+/// - "-0.0"
+fn gen_number_case_with_sign(number: &str) -> (Vec<String>, Vec<SelectItem>) {
+    let (mut input, mut expected) = gen_number_case(number);
+    for op in [UnaryOperator::Plus, UnaryOperator::Minus] {
+        let (input_sign, expected_sign) = gen_sign_number_case(number, op);
+        input.extend(input_sign);
+        expected.extend(expected_sign);
+    }
+    (input, expected)
+}
+
 #[test]
 fn parse_negative_value() {
     let sql1 = "SELECT -1";
@@ -12470,6 +12579,41 @@ fn parse_composite_access_expr() {
     all_dialects_where(|d| d.supports_struct_literal()).verified_stmt(
         "SELECT * FROM t WHERE STRUCT(STRUCT(1 AS a, NULL AS b) AS c, NULL AS d).c.a IS NOT NULL",
     );
+    let support_struct = all_dialects_where(|d| d.supports_struct_literal());
+    let stmt = support_struct
+        .verified_only_select("SELECT STRUCT(STRUCT(1 AS a, NULL AS b) AS c, NULL AS d).c.a");
+    let expected = SelectItem::UnnamedExpr(Expr::CompoundFieldAccess {
+        root: Box::new(Expr::Struct {
+            values: vec![
+                Expr::Named {
+                    name: Ident::new("c"),
+                    expr: Box::new(Expr::Struct {
+                        values: vec![
+                            Expr::Named {
+                                name: Ident::new("a"),
+                                expr: Box::new(Expr::Value(Number("1".parse().unwrap(), false))),
+                            },
+                            Expr::Named {
+                                name: Ident::new("b"),
+                                expr: Box::new(Expr::Value(Value::Null)),
+                            },
+                        ],
+                        fields: vec![],
+                    }),
+                },
+                Expr::Named {
+                    name: Ident::new("d"),
+                    expr: Box::new(Expr::Value(Value::Null)),
+                },
+            ],
+            fields: vec![],
+        }),
+        access_chain: vec![
+            AccessExpr::Dot(Expr::Identifier(Ident::new("c"))),
+            AccessExpr::Dot(Expr::Identifier(Ident::new("a"))),
+        ],
+    });
+    assert_eq!(stmt.projection[0], expected);
 }
 
 #[test]