3929938005

Build Type

push

github

Committed by GitHub

Commit Message

Merge #713

Run Details

84930 of 96741 relevant lines covered (87.79%)

79640.1 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/operators/src/processing/map_query.rs

use crate::adapters::SparseTilesFillAdapter;
use crate::engine::{QueryContext, RasterQueryProcessor, VectorQueryProcessor};
use crate::util::Result;
use async_trait::async_trait;
use futures::stream::BoxStream;
use futures::StreamExt;
use geoengine_datatypes::primitives::{RasterQueryRectangle, VectorQueryRectangle};
use geoengine_datatypes::raster::{RasterTile2D, TilingSpecification};

/// This `QueryProcessor` allows to rewrite a query. It does not change the data. Results of the children are forwarded.
pub(crate) struct MapQueryProcessor<S, Q, A> {
    source: S,
    query_fn: Q,
    additional_data: A,
}

impl<S, Q, A> MapQueryProcessor<S, Q, A> {
    pub fn new(source: S, query_fn: Q, additional_data: A) -> Self {
        Self {
            source,
            query_fn,
            additional_data,
        }
    }
}

#[async_trait]
impl<S, Q> RasterQueryProcessor for MapQueryProcessor<S, Q, TilingSpecification>
where
    S: RasterQueryProcessor,
    Q: Fn(RasterQueryRectangle) -> Result<Option<RasterQueryRectangle>> + Sync + Send,
{
    type RasterType = S::RasterType;
    async fn raster_query<'a>(
        &'a self,
        query: RasterQueryRectangle,
        ctx: &'a dyn QueryContext,
    ) -> Result<BoxStream<'a, Result<RasterTile2D<S::RasterType>>>> {
        let rewritten_query = (self.query_fn)(query)?;

        if let Some(rewritten_query) = rewritten_query {
            self.source.raster_query(rewritten_query, ctx).await
        } else {
            log::debug!("Query was rewritten to empty query. Returning empty / filled stream.");
            let s = futures::stream::empty();

            Ok(SparseTilesFillAdapter::new_like_subquery(s, query, self.additional_data).boxed())
        }
    }
}

#[async_trait]
impl<S, Q> VectorQueryProcessor for MapQueryProcessor<S, Q, ()>
where
    S: VectorQueryProcessor,
    Q: Fn(VectorQueryRectangle) -> Result<Option<VectorQueryRectangle>> + Sync + Send,
    S::VectorType: Send,
{
    type VectorType = S::VectorType;
    async fn vector_query<'a>(
        &'a self,
        query: VectorQueryRectangle,
        ctx: &'a dyn QueryContext,
    ) -> Result<BoxStream<'a, Result<Self::VectorType>>> {
        let rewritten_query = (self.query_fn)(query)?;
        if let Some(rewritten_query) = rewritten_query {
            self.source.vector_query(rewritten_query, ctx).await
        } else {
            log::debug!("Query was rewritten to empty query. Returning empty stream.");
            Ok(Box::pin(futures::stream::empty())) // TODO: should be empty collection?
        }
    }
}

1	use crate::adapters::SparseTilesFillAdapter;
2	use crate::engine::{QueryContext, RasterQueryProcessor, VectorQueryProcessor};
3	use crate::util::Result;
4	use async_trait::async_trait;
5	use futures::stream::BoxStream;
6	use futures::StreamExt;
7	use geoengine_datatypes::primitives::{RasterQueryRectangle, VectorQueryRectangle};
8	use geoengine_datatypes::raster::{RasterTile2D, TilingSpecification};
9
10	/// This `QueryProcessor` allows to rewrite a query. It does not change the data. Results of the children are forwarded.
11	pub(crate) struct MapQueryProcessor<S, Q, A> {
12	source: S,
13	query_fn: Q,
14	additional_data: A,
15	}
16
17	impl<S, Q, A> MapQueryProcessor<S, Q, A> {
18	pub fn new(source: S, query_fn: Q, additional_data: A) -> Self {	×
19	Self {	×
20	source,	×
21	query_fn,	×
22	additional_data,	×
23	}	×
24	}	×
25	}
26
27	#[async_trait]
28	impl<S, Q> RasterQueryProcessor for MapQueryProcessor<S, Q, TilingSpecification>
29	where
30	S: RasterQueryProcessor,
31	Q: Fn(RasterQueryRectangle) -> Result<Option<RasterQueryRectangle>> + Sync + Send,
32	{
33	type RasterType = S::RasterType;
34	async fn raster_query<'a>(	×
35	&'a self,	×
36	query: RasterQueryRectangle,	×
37	ctx: &'a dyn QueryContext,	×
38	) -> Result<BoxStream<'a, Result<RasterTile2D<S::RasterType>>>> {	×
39	let rewritten_query = (self.query_fn)(query)?;	×
40
41	if let Some(rewritten_query) = rewritten_query {	×
42	self.source.raster_query(rewritten_query, ctx).await	×
43	} else {
44	log::debug!("Query was rewritten to empty query. Returning empty / filled stream.");	×
45	let s = futures::stream::empty();	×
46		×
47	Ok(SparseTilesFillAdapter::new_like_subquery(s, query, self.additional_data).boxed())	×
48	}
49	}	×
50	}
51
52	#[async_trait]
53	impl<S, Q> VectorQueryProcessor for MapQueryProcessor<S, Q, ()>
54	where
55	S: VectorQueryProcessor,
56	Q: Fn(VectorQueryRectangle) -> Result<Option<VectorQueryRectangle>> + Sync + Send,
57	S::VectorType: Send,
58	{
59	type VectorType = S::VectorType;
60	async fn vector_query<'a>(	×
61	&'a self,	×
62	query: VectorQueryRectangle,	×
63	ctx: &'a dyn QueryContext,	×
64	) -> Result<BoxStream<'a, Result<Self::VectorType>>> {	×
65	let rewritten_query = (self.query_fn)(query)?;	×
66	if let Some(rewritten_query) = rewritten_query {	×
67	self.source.vector_query(rewritten_query, ctx).await	×
68	} else {
69	log::debug!("Query was rewritten to empty query. Returning empty stream.");	×
70	Ok(Box::pin(futures::stream::empty())) // TODO: should be empty collection?	×
71	}
72	}	×
73	}

geo-engine / geoengine / 3929938005

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous