[chore] add passthrough query as a tablefactor (#32)

We want to have the capability to specify subquery of a SQL string that
we don't necessarily need to parse. This passthrough query will be only
created at runtime and serialized as it is.
The main purpose here is performance and to avoid any potential parsing
bugs with already known valid SQL.

Author: ayman-sigma

src/ast/query.rs

@@ -1135,6 +1135,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,
@@ -1767,6 +1773,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

@@ -1876,6 +1876,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

@@ -11971,7 +11971,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

@@ -14124,6 +14124,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() {
     verified_stmt("UPDATE t1 FROM (SELECT name, id FROM t1 GROUP BY id) AS t2 SET name = t2.name WHERE t1.id = t2.id");