Batch bus-related queries to eliminate N+1 in GetStationsByLineIdList

stationapi/src/domain/repository/line_repository.rs

@@ -15,6 +15,10 @@ pub trait LineRepository: Send + Sync + 'static {
         &self,
         station_group_id_vec: &[u32],
     ) -> Result<Vec<Line>, DomainError>;
+    async fn get_by_station_group_id_vec_no_types(
+        &self,
+        station_group_id_vec: &[u32],
+    ) -> Result<Vec<Line>, DomainError>;
     async fn get_by_line_group_id(&self, line_group_id: u32) -> Result<Vec<Line>, DomainError>;
     async fn get_by_line_group_id_vec(
         &self,
@@ -229,6 +233,13 @@ mod tests {
             Ok(result)
         }
 
+        async fn get_by_station_group_id_vec_no_types(
+            &self,
+            station_group_id_vec: &[u32],
+        ) -> Result<Vec<Line>, DomainError> {
+            self.get_by_station_group_id_vec(station_group_id_vec).await
+        }
+
         async fn get_by_line_group_id(&self, line_group_id: u32) -> Result<Vec<Line>, DomainError> {
             Ok(self
                 .lines_by_line_group_id

stationapi/src/domain/repository/station_repository.rs

@@ -47,6 +47,11 @@ pub trait StationRepository: Send + Sync + 'static {
         &self,
         line_group_ids: &[u32],
     ) -> Result<Vec<Station>, DomainError>;
+    async fn get_bus_stops_near_stations(
+        &self,
+        coords: &[(u32, f64, f64)], // (station_g_cd, lat, lon)
+        limit_per_station: u32,
+    ) -> Result<Vec<(u32, Station)>, DomainError>;
     async fn get_route_stops(
         &self,
         from_station_id: u32,
@@ -195,6 +200,23 @@ mod tests {
             Ok(result)
         }
 
+        async fn get_bus_stops_near_stations(
+            &self,
+            coords: &[(u32, f64, f64)],
+            limit_per_station: u32,
+        ) -> Result<Vec<(u32, Station)>, DomainError> {
+            let mut result = Vec::new();
+            for &(source_g_cd, lat, lon) in coords {
+                let stops = self
+                    .get_by_coordinates(lat, lon, Some(limit_per_station), Some(TransportType::Bus))
+                    .await?;
+                for stop in stops {
+                    result.push((source_g_cd, stop));
+                }
+            }
+            Ok(result)
+        }
+
         async fn get_by_name(
             &self,
             station_name: String,

stationapi/src/infrastructure/line_repository.rs

@@ -124,6 +124,19 @@ impl LineRepository for MyLineRepository {
         let mut conn = self.pool.acquire().await?;
         InternalLineRepository::get_by_station_group_id_vec(&station_group_id_vec, &mut conn).await
     }
+    async fn get_by_station_group_id_vec_no_types(
+        &self,
+        station_group_id_vec: &[u32],
+    ) -> Result<Vec<Line>, DomainError> {
+        let station_group_id_vec: Vec<i64> =
+            station_group_id_vec.iter().map(|x| *x as i64).collect();
+        let mut conn = self.pool.acquire().await?;
+        InternalLineRepository::get_by_station_group_id_vec_no_types(
+            &station_group_id_vec,
+            &mut conn,
+        )
+        .await
+    }
     async fn get_by_line_group_id(&self, line_group_id: u32) -> Result<Vec<Line>, DomainError> {
         let line_group_id: i64 = line_group_id as i64;
         let mut conn = self.pool.acquire().await?;
@@ -456,6 +469,82 @@ impl InternalLineRepository {
         Ok(lines)
     }
 
+    async fn get_by_station_group_id_vec_no_types(
+        station_group_id_vec: &[i64],
+        conn: &mut PgConnection,
+    ) -> Result<Vec<Line>, DomainError> {
+        if station_group_id_vec.is_empty() {
+            return Ok(vec![]);
+        }
+
+        let params = (1..=station_group_id_vec.len())
+            .map(|i| format!("${i}"))
+            .collect::<Vec<_>>()
+            .join(", ");
+        let query_str = format!(
+            "SELECT DISTINCT ON (l.line_cd, s.station_g_cd)
+                l.line_cd,
+                l.company_cd,
+                l.line_type,
+                l.line_symbol1,
+                l.line_symbol2,
+                l.line_symbol3,
+                l.line_symbol4,
+                l.line_symbol1_color,
+                l.line_symbol2_color,
+                l.line_symbol3_color,
+                l.line_symbol4_color,
+                l.line_symbol1_shape,
+                l.line_symbol2_shape,
+                l.line_symbol3_shape,
+                l.line_symbol4_shape,
+                l.e_status,
+                l.e_sort,
+                COALESCE(l.average_distance, 0.0)::DOUBLE PRECISION AS average_distance,
+                s.station_cd,
+                s.station_g_cd,
+                NULL::int AS line_group_cd,
+                NULL::int AS type_cd,
+                COALESCE(a.line_name, l.line_name) AS line_name,
+                COALESCE(a.line_name_k, l.line_name_k) AS line_name_k,
+                COALESCE(a.line_name_h, l.line_name_h) AS line_name_h,
+                COALESCE(a.line_name_r, l.line_name_r) AS line_name_r,
+                COALESCE(a.line_name_zh, l.line_name_zh) AS line_name_zh,
+                COALESCE(a.line_name_ko, l.line_name_ko) AS line_name_ko,
+                COALESCE(a.line_color_c, l.line_color_c) AS line_color_c,
+                l.transport_type
+            FROM lines AS l
+            JOIN stations AS s ON s.station_g_cd IN ( {params} )
+            AND s.e_status = 0
+            AND s.line_cd = l.line_cd
+            LEFT JOIN line_aliases AS la ON la.station_cd = s.station_cd
+            LEFT JOIN aliases AS a ON la.alias_cd = a.id
+            WHERE l.e_status = 0
+            AND NOT EXISTS (
+                SELECT 1 FROM station_station_types sst
+                WHERE sst.station_cd = s.station_cd
+                AND sst.line_group_cd IS NOT NULL
+                AND sst.pass = 1
+                AND NOT EXISTS (
+                    SELECT 1 FROM station_station_types sst2
+                    WHERE sst2.station_cd = s.station_cd
+                    AND sst2.line_group_cd IS NOT NULL
+                    AND sst2.pass <> 1
+                )
+            )"
+        );
+
+        let mut query = sqlx::query_as::<_, LineRow>(&query_str);
+        for id in station_group_id_vec {
+            query = query.bind(id);
+        }
+
+        let rows = query.fetch_all(conn).await?;
+        let lines: Vec<Line> = rows.into_iter().map(|row| row.into()).collect();
+
+        Ok(lines)
+    }
+
     async fn get_by_line_group_id(
         line_group_id: i64,
         conn: &mut PgConnection,