Support EXECUTE ... USING for Postgres (apache#1153)

Author: jonathanlehto

src/ast/mod.rs

@@ -2404,11 +2404,15 @@ pub enum Statement {
     /// Note: this is a PostgreSQL-specific statement.
     Deallocate { name: Ident, prepare: bool },
     /// ```sql
-    /// EXECUTE name [ ( parameter [, ...] ) ]
+    /// EXECUTE name [ ( parameter [, ...] ) ] [USING <expr>]
     /// ```
     ///
     /// Note: this is a PostgreSQL-specific statement.
-    Execute { name: Ident, parameters: Vec<Expr> },
+    Execute {
+        name: Ident,
+        parameters: Vec<Expr>,
+        using: Vec<Expr>,
+    },
     /// ```sql
     /// PREPARE name [ ( data_type [, ...] ) ] AS statement
     /// ```
@@ -3824,11 +3828,18 @@ impl fmt::Display for Statement {
                 prepare = if *prepare { "PREPARE " } else { "" },
                 name = name,
             ),
-            Statement::Execute { name, parameters } => {
+            Statement::Execute {
+                name,
+                parameters,
+                using,
+            } => {
                 write!(f, "EXECUTE {name}")?;
                 if !parameters.is_empty() {
                     write!(f, "({})", display_comma_separated(parameters))?;
                 }
+                if !using.is_empty() {
+                    write!(f, " USING {}", display_comma_separated(using))?;
+                };
                 Ok(())
             }
             Statement::Prepare {

src/parser/mod.rs

@@ -8948,7 +8948,20 @@ impl<'a> Parser<'a> {
             self.expect_token(&Token::RParen)?;
         }
 
-        Ok(Statement::Execute { name, parameters })
+        let mut using = vec![];
+        if self.parse_keyword(Keyword::USING) {
+            using.push(self.parse_expr()?);
+
+            while self.consume_token(&Token::Comma) {
+                using.push(self.parse_expr()?);
+            }
+        };
+
+        Ok(Statement::Execute {
+            name,
+            parameters,
+            using,
+        })
     }
 
     pub fn parse_prepare(&mut self) -> Result<Statement, ParserError> {

tests/sqlparser_postgres.rs

@@ -1421,6 +1421,7 @@ fn parse_execute() {
         Statement::Execute {
             name: "a".into(),
             parameters: vec![],
+            using: vec![]
         }
     );
 
@@ -1433,6 +1434,29 @@ fn parse_execute() {
                 Expr::Value(number("1")),
                 Expr::Value(Value::SingleQuotedString("t".to_string()))
             ],
+            using: vec![]
+        }
+    );
+
+    let stmt = pg_and_generic()
+        .verified_stmt("EXECUTE a USING CAST(1337 AS SMALLINT), CAST(7331 AS SMALLINT)");
+    assert_eq!(
+        stmt,
+        Statement::Execute {
+            name: "a".into(),
+            parameters: vec![],
+            using: vec![
+                Expr::Cast {
+                    expr: Box::new(Expr::Value(Value::Number("1337".parse().unwrap(), false))),
+                    data_type: DataType::SmallInt(None),
+                    format: None
+                },
+                Expr::Cast {
+                    expr: Box::new(Expr::Value(Value::Number("7331".parse().unwrap(), false))),
+                    data_type: DataType::SmallInt(None),
+                    format: None
+                },
+            ]
         }
     );
 }