Update overpass_parser_rust, multiple sql statement

Author: frodrigo

Cargo.lock

@@ -8,9 +8,9 @@ pub trait Backend {
 
     async fn init(&self) -> ();
 
-    fn parse_query(&self, query: &str) -> Result<String, String>;
+    fn parse_query(&self, query: &str) -> Result<Vec<String>, String>;
 
-    async fn exec(&mut self, query: String) -> Vec<String>;
+    async fn exec(&mut self, query: Vec<String>) -> Vec<String>;
 }
 
 pub enum BackendType {
@@ -72,7 +72,7 @@ impl BackendType {
         }
     }
 
-    pub fn parse_query(&self, query: &str) -> Result<String, String> {
+    pub fn parse_query(&self, query: &str) -> Result<Vec<String>, String> {
         match self {
             #[cfg(feature = "postgres")]
             BackendType::PostgresOsmosis(backend) => backend.parse_query(query),
@@ -81,12 +81,12 @@ impl BackendType {
         }
     }
 
-    pub async fn exec(&mut self, query: String) -> Vec<String> {
+    pub async fn exec(&mut self, queries: Vec<String>) -> Vec<String> {
         match self {
             #[cfg(feature = "postgres")]
-            BackendType::PostgresOsmosis(backend) => backend.exec(query).await,
+            BackendType::PostgresOsmosis(backend) => backend.exec(queries).await,
             #[cfg(feature = "duckdb")]
-            BackendType::DuckdbQuackosm(backend) => backend.exec(query).await,
+            BackendType::DuckdbQuackosm(backend) => backend.exec(queries).await,
         }
     }
 }

src/backend.rs

@@ -49,15 +49,23 @@ impl Backend for DuckdbQuackosm {
         );
     }
 
-    fn parse_query(&self, query: &str) -> Result<String, String> {
+    fn parse_query(&self, query: &str) -> Result<Vec<String>, String> {
         match parse_query(query) {
             Ok(request) => Ok(request.to_sql(&*self.dialect, "4326", None)),
             Err(e) => Err(e.to_string()),
         }
     }
 
-    async fn exec(&mut self, sql: String) -> Vec<String> {
-        let mut stmt = self.con.prepare(&sql).expect("Failed to execute SQL query");
+    async fn exec(&mut self, sqls: Vec<String>) -> Vec<String> {
+        let mut sqls = sqls;
+        let last_sql = sqls.pop().expect("No SQL queries to execute");
+        self.con
+            .execute_batch(sqls.join("\n").as_str())
+            .expect("Failed to execute SQL query");
+        let mut stmt = self
+            .con
+            .prepare(&last_sql)
+            .expect("Failed to execute SQL query");
         stmt.query_map([], |row| Ok(row.get::<usize, String>(0).unwrap()))
             .unwrap()
             .map(|result| result.ok().unwrap())

src/duckdb_quackosm/mod.rs

@@ -51,7 +51,7 @@ impl Backend for PostgresOsmosis {
         Self::exec_sql_file(&self.con, "src/postgres_osmosis/init.sql").await;
     }
 
-    fn parse_query(&self, query: &str) -> Result<String, String> {
+    fn parse_query(&self, query: &str) -> Result<Vec<String>, String> {
         match parse_query(query) {
             Err(e) => Err(e.to_string()),
             Ok(request) => {
@@ -92,18 +92,15 @@ GROUP BY
         }
     }
 
-    async fn exec(&mut self, sql: String) -> Vec<String> {
-        let mut sql = sql.to_string();
-        if sql.starts_with("SET statement_timeout") {
-            let (timeout, s) = sql.split_once(';').unwrap();
-            self.con
-                .execute(&timeout.to_string(), &[])
-                .await
-                .expect("Failed to set statement timeout");
-            sql = s.to_string();
-        }
+    async fn exec(&mut self, sqls: Vec<String>) -> Vec<String> {
+        let mut sqls = sqls;
+        let last_sql = sqls.pop().expect("No SQL queries to execute").to_string();
+        self.con
+            .batch_execute(sqls.join("\n").as_str())
+            .await
+            .expect("Failed to execute SQL query");
         self.con
-            .query(&sql.to_string(), &[])
+            .query(&last_sql.to_string(), &[])
             .await
             .expect("Failed to execute SQL query")
             .iter()

src/postgres_osmosis/mod.rs

@@ -24,12 +24,12 @@ class Connection {
   }
 
   async query(overpass: string): Promise<IterableIterator<Object>> {
-    const sql = await underpass.query(overpass)
+    const sqls = (await underpass.query(overpass)).join('\n');
     this.status(`Parsing Overpass query\n${overpass}`);
 
-    this.status(`SQL query\n${sql}`);
+    this.status(`SQL query\n${sqls}`);
     const startTimeS = performance.now();
-    const result = await this.connection.query(sql);
+    const result = await this.connection.query(sqls);
     const endTimeS = performance.now();
     this.status(`Execution of SQL query in ${endTimeS - startTimeS}ms`);
 

underpass-wasm/src/index.ts

@@ -12,7 +12,7 @@ pub fn prepare(parquet: &str) -> String {
 }
 
 #[wasm_bindgen]
-pub async fn query(query: &str) -> Result<String, String> {
+pub async fn query(query: &str) -> Result<Vec<String>, String> {
     match parse_query(query) {
         Ok(request) => Ok(request.to_sql(
             &Duckdb as &(dyn SqlDialect + Send + Sync),