Execute side-effect statements before trailing SELECT

transform_global_sql returned empty side-effects when a SELECT was
present, so CREATE/INSERT preambles were skipped. Hoist side-effect
extraction so it runs regardless of the query type.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: teunbrand

src/execute/cte.rs

@@ -219,18 +219,39 @@ pub fn transform_global_sql(
     source_tree: &SourceTree,
     materialized_ctes: &HashSet<String>,
 ) -> (Vec<String>, Option<String>) {
+    // Collect side-effect statements (CREATE, INSERT, UPDATE, DELETE) that
+    // need to run before the main query. These appear alongside a trailing
+    // SELECT or VISUALISE FROM.
+    //
+    // Only structured DML is handled here — other_sql_statement nodes
+    // (INSTALL, LOAD, SET, …) are pre-executed in prepare_data_with_reader.
+    let root = source_tree.root();
+
+    let side_effect_stmts = r#"
+        (sql_statement
+          [(create_statement)
+           (insert_statement)
+           (update_statement)
+           (delete_statement)] @stmt)
+    "#;
+    let side_effects: Vec<String> = source_tree
+        .find_texts(&root, side_effect_stmts)
+        .into_iter()
+        .map(|s| transform_cte_references(s.trim(), materialized_ctes))
+        .filter(|s| !s.is_empty())
+        .collect();
+
     // Try to extract trailing SELECT (WITH...SELECT or direct SELECT)
     let select_sql = split_with_query(source_tree)
         .map(|(_, select)| select)
         .or_else(|| {
             // Fallback: direct SELECT statement (no WITH clause)
-            let root = source_tree.root();
             source_tree.find_text(&root, "(sql_statement (select_statement) @select)")
         });
 
     if let Some(select_sql) = select_sql {
         return (
-            vec![],
+            side_effects,
             Some(transform_cte_references(&select_sql, materialized_ctes)),
         );
     }
@@ -239,30 +260,10 @@ pub fn transform_global_sql(
         return (vec![], None);
     }
 
-    // We have non-SELECT executable SQL (CREATE, INSERT, …) and/or
-    // VISUALISE FROM. Split them: side-effect statements run directly,
-    // VISUALISE FROM becomes the queryable part.
-    //
-    // Only structured DML is handled here — other_sql_statement nodes
-    // (INSTALL, LOAD, SET, …) are pre-executed in prepare_data_with_reader.
+    // We have non-SELECT executable SQL and/or VISUALISE FROM.
+    // Side-effects run directly, VISUALISE FROM becomes the queryable part.
     // A bare WITH clause without a trailing statement is not executable on
     // its own (its CTEs are already materialized separately).
-    let root = source_tree.root();
-
-    let side_effect_stmts = r#"
-        (sql_statement
-          [(create_statement)
-           (insert_statement)
-           (update_statement)
-           (delete_statement)] @stmt)
-    "#;
-    let side_effects: Vec<String> = source_tree
-        .find_texts(&root, side_effect_stmts)
-        .into_iter()
-        .map(|s| transform_cte_references(s.trim(), materialized_ctes))
-        .filter(|s| !s.is_empty())
-        .collect();
-
     let viz_from_query = source_tree
         .find_text(
             &root,

src/execute/mod.rs

@@ -1947,6 +1947,27 @@ mod tests {
         assert_eq!(result.data.get(key).unwrap().height(), 3);
     }
 
+    #[cfg(feature = "duckdb")]
+    #[test]
+    fn test_select_after_create_and_insert() {
+        let reader = DuckDBReader::from_connection_string("duckdb://memory").unwrap();
+
+        let query = r#"
+            CREATE TEMP TABLE data(x INTEGER, y INTEGER);
+            INSERT INTO data VALUES (1, 10), (2, 20), (3, 30);
+            SELECT * FROM data
+            VISUALISE x, y
+            DRAW point
+        "#;
+
+        let result = prepare_data_with_reader(query, &reader).unwrap();
+        let key = result.specs[0].layers[0]
+            .data_key
+            .as_ref()
+            .expect("Layer should have data_key");
+        assert_eq!(result.data.get(key).unwrap().height(), 3);
+    }
+
     /// Test that literal mappings survive stat transforms (e.g., histogram grouping).
     ///
     /// This tests the fix for issue #129 where literal aesthetic columns like