add passthrough query as a tablefactor

Author: ayman-sigma

src/ast/query.rs

@@ -1013,6 +1013,12 @@ pub enum TableFactor {
         subquery: Box<Query>,
         alias: Option<TableAlias>,
     },
+    /// A pass-through query string that is not parsed.
+    /// This is useful while building/rewriting queries with a known valid SQL string and to avoid parsing it.
+    PassThroughQuery {
+        query: String,
+        alias: Option<TableAlias>,
+    },
     /// `TABLE(<expr>)[ AS <alias> ]`
     TableFunction {
         expr: Expr,
@@ -1641,6 +1647,13 @@ impl fmt::Display for TableFactor {
                 }
                 Ok(())
             }
+            TableFactor::PassThroughQuery { query, alias } => {
+                write!(f, "({query})")?;
+                if let Some(alias) = alias {
+                    write!(f, " AS {alias}")?;
+                }
+                Ok(())
+            }
             TableFactor::Function {
                 lateral,
                 name,

src/ast/spans.rs

@@ -1733,6 +1733,8 @@ impl Spanned for TableFactor {
             } => subquery
                 .span()
                 .union_opt(&alias.as_ref().map(|alias| alias.span())),
+            // This is usually created at runtime, so we don't have a span for it
+            TableFactor::PassThroughQuery { query: _, alias: _ } => Span::empty(),
             TableFactor::TableFunction { expr, alias } => expr
                 .span()
                 .union_opt(&alias.as_ref().map(|alias| alias.span())),

src/parser/mod.rs

@@ -10805,7 +10805,8 @@ impl<'a> Parser<'a> {
                         | TableFactor::Pivot { alias, .. }
                         | TableFactor::Unpivot { alias, .. }
                         | TableFactor::MatchRecognize { alias, .. }
-                        | TableFactor::NestedJoin { alias, .. } => {
+                        | TableFactor::NestedJoin { alias, .. }
+                        | TableFactor::PassThroughQuery { alias, .. } => {
                             // but not `FROM (mytable AS alias1) AS alias2`.
                             if let Some(inner_alias) = alias {
                                 return Err(ParserError::ParserError(format!(

tests/sqlparser_common.rs

@@ -12728,6 +12728,29 @@ fn parse_select_without_projection() {
     dialects.verified_stmt("SELECT FROM users");
 }
 
+#[test]
+fn ast_with_pass_through_query() {
+    let sql = "SELECT * FROM t1 AS t2";
+    let mut ast = all_dialects().verified_stmt(sql);
+    let Statement::Query(ref mut query) = ast else {
+        panic!("Expected Query");
+    };
+    let SetExpr::Select(ref mut select) = *query.body else {
+        panic!("Expected SetExpr::Select");
+    };
+    let from = select.from.get_mut(0).unwrap();
+    from.relation = TableFactor::PassThroughQuery {
+        query: "SELECT * FROM tx".to_string(),
+        alias: Some(TableAlias {
+            name: Ident::new("ty"),
+            columns: vec![],
+        }),
+    };
+
+    // After modifying the AST, the SQL representation should be different
+    assert_eq!(ast.to_string(), "SELECT * FROM (SELECT * FROM tx) AS ty");
+}
+
 #[test]
 fn parse_update_from_before_select() {
     all_dialects()