Address review: DuckDB doc example and link, arrow-only dialect test

All three changes are applied review suggestions from Luca Cappelletti.

Co-Authored-By: Luca Cappelletti <7738570+LucaCappelletti94@users.noreply.github.com>
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

Author: 3 people

src/dialect/mod.rs

@@ -547,14 +547,16 @@ pub trait Dialect: Debug + Any {
     /// lambda functions, for example:
     ///
     /// ```sql
-    /// SELECT transform(array(1, 2, 3), LAMBDA x : x + 1); -- returns [2,3,4]
+    /// SELECT list_transform([1, 2, 3], lambda x : x + 1); -- returns [2, 3, 4]
     /// ```
     ///
     /// This spelling does not claim the `->` token, so it can be enabled by
     /// dialects that already give `->` a different meaning, such as PostgreSQL
     /// and its derivatives, where `->` is JSON member access. Defaults to
     /// [`Self::supports_lambda_functions`], so dialects supporting the `->`
     /// spelling accept the `LAMBDA` spelling too unless they say otherwise.
+    ///
+    /// See <https://duckdb.org/docs/stable/sql/functions/lambda>
     fn supports_lambda_keyword_syntax(&self) -> bool {
         self.supports_lambda_functions()
     }

tests/sqlparser_custom_dialect.rs

@@ -249,3 +249,38 @@ fn custom_dialect_lambda_keyword_defaults_to_arrow_support() {
         );
     }
 }
+
+#[test]
+fn custom_dialect_lambda_arrow_syntax_without_keyword() {
+    // Arrow lambdas stay on while the `LAMBDA` keyword spelling is off,
+    // as in engines like Spark and Snowflake.
+    #[derive(Debug)]
+    struct MyDialect {}
+
+    impl Dialect for MyDialect {
+        fn is_identifier_start(&self, ch: char) -> bool {
+            is_identifier_start(ch)
+        }
+
+        fn is_identifier_part(&self, ch: char) -> bool {
+            is_identifier_part(ch)
+        }
+
+        fn supports_lambda_functions(&self) -> bool {
+            true
+        }
+
+        fn supports_lambda_keyword_syntax(&self) -> bool {
+            false
+        }
+    }
+
+    let dialect = MyDialect {};
+
+    let sql = "SELECT transform(xs, x -> x + 1)";
+    assert_eq!(
+        sql,
+        &format!("{}", Parser::parse_sql(&dialect, sql).unwrap()[0])
+    );
+    assert!(Parser::parse_sql(&dialect, "SELECT transform(xs, lambda x : x + 1)").is_err());
+}