SQLite: Support with a table name or table-valued function

Author: LucaCappelletti94

src/ast/mod.rs

@@ -1002,6 +1002,19 @@ pub enum Expr {
         /// `true` when the `NOT` modifier is present.
         negated: bool,
     },
+    /// `[ NOT ] IN table_name` or `[ NOT ] IN schema.table_name(args)` (SQLite)
+    ///
+    /// See <https://www.sqlite.org/lang_expr.html>
+    InTable {
+        /// Left-hand expression to test for membership.
+        expr: Box<Expr>,
+        /// Table or table-valued function name.
+        table: ObjectName,
+        /// Table-valued function arguments, `None` for a plain table name.
+        args: Option<Vec<FunctionArg>>,
+        /// `true` when the `NOT` modifier is present.
+        negated: bool,
+    },
     /// `<expr> [ NOT ] BETWEEN <low> AND <high>`
     Between {
         /// Expression being compared.
@@ -1823,6 +1836,24 @@ impl fmt::Display for Expr {
                 if *negated { "NOT " } else { "" },
                 array_expr
             ),
+            Expr::InTable {
+                expr,
+                table,
+                args,
+                negated,
+            } => {
+                write!(
+                    f,
+                    "{} {}IN {}",
+                    expr,
+                    if *negated { "NOT " } else { "" },
+                    table
+                )?;
+                if let Some(args) = args {
+                    write!(f, "({})", display_comma_separated(args))?;
+                }
+                Ok(())
+            }
             Expr::Between {
                 expr,
                 negated,

src/ast/spans.rs

@@ -1522,6 +1522,16 @@ impl Spanned for Expr {
                 array_expr,
                 negated: _,
             } => expr.span().union(&array_expr.span()),
+            Expr::InTable {
+                expr,
+                negated: _,
+                table,
+                args,
+            } => union_spans(
+                core::iter::once(expr.span())
+                    .chain(core::iter::once(table.span()))
+                    .chain(args.iter().flatten().map(|a| a.span())),
+            ),
             Expr::Between {
                 expr,
                 negated: _,

src/dialect/mod.rs

@@ -453,6 +453,12 @@ pub trait Dialect: Debug + Any {
         false
     }
 
+    /// Returns true if the dialect supports a table name or table-valued function
+    /// as the right-hand side of `IN`, e.g. `x IN t`, `x IN schema.t`, or `x IN f(args)`.
+    fn supports_in_table_expression(&self) -> bool {
+        false
+    }
+
     /// Returns true if the dialect supports `BEGIN {DEFERRED | IMMEDIATE | EXCLUSIVE | TRY | CATCH} [TRANSACTION]` statements
     fn supports_start_transaction_modifier(&self) -> bool {
         false
@@ -2138,6 +2144,10 @@ mod tests {
                 self.0.supports_in_unparenthesized_expr()
             }
 
+            fn supports_in_table_expression(&self) -> bool {
+                self.0.supports_in_table_expression()
+            }
+
             fn convert_type_before_value(&self) -> bool {
                 self.0.convert_type_before_value()
             }

src/dialect/sqlite.rs

@@ -129,4 +129,8 @@ impl Dialect for SQLiteDialect {
     fn supports_numeric_literal_underscores(&self) -> bool {
         true
     }
+
+    fn supports_in_table_expression(&self) -> bool {
+        true
+    }
 }

src/parser/mod.rs

@@ -4427,6 +4427,24 @@ impl<'a> Parser<'a> {
                 negated,
             });
         }
+        if self.dialect.supports_in_table_expression()
+            && matches!(self.peek_token_ref().token, Token::Word(_))
+        {
+            let table = self.parse_object_name(false)?;
+            let args = if self.consume_token(&Token::LParen) {
+                let args = self.parse_comma_separated0(Self::parse_function_args, Token::RParen)?;
+                self.expect_token(&Token::RParen)?;
+                Some(args)
+            } else {
+                None
+            };
+            return Ok(Expr::InTable {
+                expr: Box::new(expr),
+                table,
+                args,
+                negated,
+            });
+        }
         if self.dialect.supports_in_unparenthesized_expr()
             && self.peek_token_ref().token != Token::LParen
         {

tests/sqlparser_common.rs

@@ -2605,8 +2605,10 @@ fn parse_in_error() {
     // <expr> IN <expr> is no valid, except in dialects that accept an
     // unparenthesized expression as the IN right-hand side (e.g. ClickHouse).
     let sql = "SELECT * FROM customers WHERE segment in segment";
-    let res =
-        all_dialects_except(|d| d.supports_in_unparenthesized_expr()).parse_sql_statements(sql);
+    let res = all_dialects_except(|d| {
+        d.supports_in_unparenthesized_expr() || d.supports_in_table_expression()
+    })
+    .parse_sql_statements(sql);
     assert_eq!(
         ParserError::ParserError("Expected: (, found: segment".to_string()),
         res.unwrap_err()

tests/sqlparser_sqlite.rs

@@ -957,6 +957,25 @@ fn parse_pattern_operators_bind_at_like_precedence() {
     }
 }
 
+#[test]
+fn test_in_table_and_table_valued_function() {
+    sqlite().verified_stmt("SELECT a IN t FROM t");
+    sqlite().verified_stmt("SELECT a IN main.t FROM t");
+    // Table-valued function with no arguments
+    sqlite().verified_stmt("SELECT a IN f() FROM t");
+    // NOT IN variants round-trip
+    sqlite().verified_stmt("SELECT a NOT IN t FROM t");
+    sqlite().verified_stmt("SELECT a NOT IN main.t FROM t");
+    sqlite().verified_stmt("SELECT a NOT IN f() FROM t");
+    // Table-valued function with arguments
+    sqlite().verified_stmt("SELECT a IN f(1, 2) FROM t");
+
+    // GenericDialect rejects bare-identifier IN (no parentheses, not UNNEST)
+    let res = TestedDialects::new(vec![Box::new(GenericDialect {})])
+        .parse_sql_statements("SELECT a IN t FROM t");
+    assert!(res.is_err(), "GenericDialect should reject IN <table>");
+}
+
 fn sqlite() -> TestedDialects {
     TestedDialects::new(vec![Box::new(SQLiteDialect {})])
 }