feat(torii-grpc): start rework to use 1 single query

crates/torii/core/src/sql/cache.rs

@@ -41,6 +41,10 @@ impl ModelCache {
     }
 
     pub async fn models(&self, selectors: &[Felt]) -> Result<Vec<Model>, Error> {
+        if selectors.is_empty() {
+            return Ok(self.model_cache.read().await.values().cloned().collect());
+        }
+
         let mut schemas = Vec::with_capacity(selectors.len());
         for selector in selectors {
             schemas.push(self.model(selector).await?);

crates/torii/grpc/src/server/mod.rs

@@ -464,95 +464,77 @@ impl DojoWorld {
             }
         };
 
-        // count query that matches filter_ids
-        let count_query = format!(
-            r#"
-                    SELECT count(*)
-                    FROM {table}
-                    {where_clause}
-                "#
-        );
-
-        // total count of rows without limit and offset
-        let mut count_query = sqlx::query_scalar(&count_query);
-        if let Some(hashed_keys) = &hashed_keys {
-            for key in &hashed_keys.hashed_keys {
-                let key = Felt::from_bytes_be_slice(key);
-                count_query = count_query.bind(format!("{:#x}", key));
+        if table == EVENT_MESSAGES_HISTORICAL_TABLE {
+            let count_query = format!(
+                r#"
+                SELECT count(*)
+                FROM {table}
+                {where_clause}
+            "#
+            );
+            let total_count = sqlx::query_scalar(&count_query)
+                .bind(entity_updated_after.clone())
+                .fetch_one(&self.pool)
+                .await?;
+            if total_count == 0 {
+                return Ok((Vec::new(), 0));
             }
-        }
 
-        if let Some(entity_updated_after) = entity_updated_after.clone() {
-            count_query = count_query.bind(entity_updated_after);
-        }
-        let total_count = count_query.fetch_optional(&self.pool).await?.unwrap_or(0);
-        if total_count == 0 {
-            return Ok((Vec::new(), 0));
+            let entities =
+                self.fetch_historical_event_messages(&format!(
+                    r#"
+                SELECT {table}.id, {table}.data, {table}.model_id, group_concat({model_relation_table}.model_id) as model_ids
+                FROM {table}
+                JOIN {model_relation_table} ON {table}.id = {model_relation_table}.entity_id
+                {where_clause}
+                GROUP BY {table}.event_id
+                ORDER BY {table}.event_id DESC
+             "#
+                ), None, limit, offset).await?;
+            return Ok((entities, total_count));
         }
 
-        // Query to get entity IDs and their model IDs
-        let mut query = if table == EVENT_MESSAGES_HISTORICAL_TABLE {
-            format!(
-                r#"
-            SELECT {table}.id, {table}.data, {table}.model_id, group_concat({model_relation_table}.model_id) as model_ids
-            FROM {table}
-            JOIN {model_relation_table} ON {table}.id = {model_relation_table}.entity_id
-            {where_clause}
-            GROUP BY {table}.event_id
-            ORDER BY {table}.event_id DESC
-         "#
-            )
-        } else {
-            format!(
-                r#"
-            SELECT {table}.id, group_concat({model_relation_table}.model_id) as model_ids
+        let count_query = format!(
+            r#"
+            SELECT count(*)
             FROM {table}
-            JOIN {model_relation_table} ON {table}.id = {model_relation_table}.entity_id
             {where_clause}
-            GROUP BY {table}.id
-            ORDER BY {table}.event_id DESC
-         "#
-            )
-        };
-
-        if limit.is_some() {
-            query += " LIMIT ?"
-        }
-
-        if offset.is_some() {
-            query += " OFFSET ?"
-        }
-
-        if table == EVENT_MESSAGES_HISTORICAL_TABLE {
-            let entities =
-                self.fetch_historical_event_messages(&query, None, limit, offset).await?;
-            return Ok((entities, total_count));
-        }
+        "#
+        );
 
-        let mut query = sqlx::query_as(&query);
+        // retrieve all schemas
+        let schemas = self
+            .model_cache
+            .models(&[])
+            .await?
+            .iter()
+            .map(|m| m.schema.clone())
+            .collect::<Vec<_>>();
+        let (query, count_query) = build_sql_query(
+            &schemas,
+            table,
+            entity_relation_column,
+            Some(&where_clause),
+            order_by,
+            limit,
+            offset,
+        )?;
+        let query = sqlx::query(&query);
         if let Some(hashed_keys) = hashed_keys {
             for key in hashed_keys.hashed_keys {
                 let key = Felt::from_bytes_be_slice(&key);
                 query = query.bind(format!("{:#x}", key));
             }
         }
-
         if let Some(entity_updated_after) = entity_updated_after.clone() {
             query = query.bind(entity_updated_after);
         }
-        query = query.bind(limit).bind(offset);
-        let db_entities: Vec<(String, String)> = query.fetch_all(&self.pool).await?;
+        let entities = query.fetch_all(&self.pool).await?;
+        let entities = entities
+            .iter()
+            .map(|row| map_row_to_entity(row, &schemas, dont_include_hashed_keys))
+            .collect::<Result<Vec<_>, Error>>()?;
 
-        let entities = self
-            .fetch_entities(
-                table,
-                entity_relation_column,
-                db_entities,
-                dont_include_hashed_keys,
-                order_by,
-                entity_models,
-            )
-            .await?;
         Ok((entities, total_count))
     }