Parse DuckDB's // integer division operator

crates/polyglot-sql/src/parser.rs

@@ -31749,8 +31749,25 @@ impl Parser {
                 let right = self.parse_power()?;
                 Expression::Mul(Box::new(BinaryOp::new(left, right)))
             } else if self.match_token(TokenType::Slash) {
-                let right = self.parse_power()?;
-                Expression::Div(Box::new(BinaryOp::new(left, right)))
+                // DuckDB `//` integer division: a second slash following `/`.
+                // (`a / / b` is invalid SQL, so this can't shadow real division.)
+                if matches!(
+                    self.config.dialect,
+                    Some(crate::dialects::DialectType::DuckDB)
+                ) && self.check(TokenType::Slash)
+                {
+                    self.advance()?;
+                    let right = self.parse_power()?;
+                    Expression::IntDiv(Box::new(crate::expressions::BinaryFunc {
+                        this: left,
+                        expression: right,
+                        original_name: None,
+                        inferred_type: None,
+                    }))
+                } else {
+                    let right = self.parse_power()?;
+                    Expression::Div(Box::new(BinaryOp::new(left, right)))
+                }
             } else if self.match_token(TokenType::Percent) {
                 let right = self.parse_power()?;
                 Expression::Mod(Box::new(BinaryOp::new(left, right)))
@@ -32048,8 +32065,25 @@ impl Parser {
                 let right = self.parse_power()?;
                 Expression::Mul(Box::new(BinaryOp::new(left, right)))
             } else if self.match_token(TokenType::Slash) {
-                let right = self.parse_power()?;
-                Expression::Div(Box::new(BinaryOp::new(left, right)))
+                // DuckDB `//` integer division: a second slash following `/`.
+                // (`a / / b` is invalid SQL, so this can't shadow real division.)
+                if matches!(
+                    self.config.dialect,
+                    Some(crate::dialects::DialectType::DuckDB)
+                ) && self.check(TokenType::Slash)
+                {
+                    self.advance()?;
+                    let right = self.parse_power()?;
+                    Expression::IntDiv(Box::new(crate::expressions::BinaryFunc {
+                        this: left,
+                        expression: right,
+                        original_name: None,
+                        inferred_type: None,
+                    }))
+                } else {
+                    let right = self.parse_power()?;
+                    Expression::Div(Box::new(BinaryOp::new(left, right)))
+                }
             } else if self.match_token(TokenType::Percent) {
                 let right = self.parse_power()?;
                 Expression::Mod(Box::new(BinaryOp::new(left, right)))

crates/polyglot-sql/tests/duckdb_integer_division.rs

@@ -0,0 +1,51 @@
+//! DuckDB `//` integer division parses to `IntDiv` and round-trips.
+use polyglot_sql::{transpile, DialectType};
+
+#[test]
+fn duckdb_int_div_round_trips() {
+    let out = transpile(
+        "SELECT 7 // 2 AS v",
+        DialectType::DuckDB,
+        DialectType::DuckDB,
+    )
+    .unwrap();
+    assert_eq!(out, vec!["SELECT 7 // 2 AS v"]);
+}
+
+#[test]
+fn duckdb_int_div_transpiles_like_other_integer_division() {
+    // Same lowering the existing MySQL `DIV` operator gets for these targets.
+    for target in [DialectType::PostgreSQL, DialectType::BigQuery] {
+        let out = transpile("SELECT 7 // 2 AS v", DialectType::DuckDB, target).unwrap();
+        assert_eq!(out, vec!["SELECT DIV(7, 2) AS v"], "target {target:?}");
+    }
+}
+
+#[test]
+fn duckdb_int_div_binds_tighter_than_addition() {
+    let out = transpile(
+        "SELECT 1 + 7 // 2 AS v",
+        DialectType::DuckDB,
+        DialectType::DuckDB,
+    )
+    .unwrap();
+    assert_eq!(out, vec!["SELECT 1 + 7 // 2 AS v"]);
+}
+
+#[test]
+fn plain_division_is_unchanged_in_duckdb_and_elsewhere() {
+    let out = transpile(
+        "SELECT 7 / 2 AS v",
+        DialectType::DuckDB,
+        DialectType::DuckDB,
+    )
+    .unwrap();
+    assert_eq!(out, vec!["SELECT 7 / 2 AS v"]);
+    let out = transpile(
+        "SELECT 7 / 2 AS v",
+        DialectType::PostgreSQL,
+        DialectType::PostgreSQL,
+    )
+    .unwrap();
+    assert_eq!(out, vec!["SELECT 7 / 2 AS v"]);
+}