def _do_search_by_product(self, query, return_fields=False, select_field_names=None, with_source_ids=False, source_filter=None, limit=None): if source_filter: product_queries = list(self._get_product_queries(source_filter)) if not product_queries: # No products match our source filter, so there will be no search results regardless. raise ValueError('No products match source filter: ' % source_filter) if len(product_queries) > 1: raise RuntimeError( "Multi-product source filters are not supported. Try adding 'product' field" ) source_queries, source_product = product_queries[0] dataset_fields = source_product.metadata_type.dataset_fields source_exprs = tuple( fields.to_expressions(dataset_fields.get, **source_queries)) else: source_exprs = None product_queries = list(self._get_product_queries(query)) if not product_queries: product = query.get('product', None) if product is None: raise ValueError('No products match search terms: %r' % query) else: raise ValueError(f"No such product: {product}") for q, product in product_queries: dataset_fields = product.metadata_type.dataset_fields query_exprs = tuple(fields.to_expressions(dataset_fields.get, **q)) select_fields = None if return_fields: # if no fields specified, select all if select_field_names is None: select_fields = tuple( field for name, field in dataset_fields.items() if not field.affects_row_selection) else: select_fields = tuple(dataset_fields[field_name] for field_name in select_field_names) with self._db.connect() as connection: yield (product, connection.search_datasets( query_exprs, source_exprs, select_fields=select_fields, limit=limit, with_source_ids=with_source_ids))
def test_build_query_expressions(): _sat_field = SimpleDocField('platform', None, None, None) _sens_field = SimpleDocField('instrument', None, None, None) _lat_field = NumericRangeDocField('lat', None, None, None) _fields = { 'platform': _sat_field, 'instrument': _sens_field, 'lat': _lat_field } assert [EqualsExpression(_sat_field, "LANDSAT_8") ] == to_expressions(_fields.get, platform="LANDSAT_8") assert [ RangeBetweenExpression(_lat_field, 4, 23.0, _range_class=NumericRange) ] == to_expressions(_fields.get, lat=Range(4, 23))
def make_query_expr(self, query, custom_offsets): """ Generate query expressions including queries based on custom fields """ product_queries = list(self._get_product_queries(query)) custom_query = dict() if not product_queries: # The key, values in query that are un-machable with info # in metadata types and product definitions, perhaps there are custom # fields, will need to handle custom fields separately canonical_query = query.copy() custom_query = { key: canonical_query.pop(key) for key in custom_offsets if key in canonical_query } product_queries = list(self._get_product_queries(canonical_query)) if not product_queries: raise ValueError('No products match search terms: %r' % query) for q, product in product_queries: dataset_fields = product.metadata_type.dataset_fields query_exprs = tuple(fields.to_expressions(dataset_fields.get, **q)) custom_query_exprs = tuple( self.get_custom_query_expressions(custom_query, custom_offsets)) yield product, query_exprs + custom_query_exprs
def _do_time_count(self, period, query, ensure_single=False): if 'time' not in query: raise ValueError( 'Counting through time requires a "time" range query argument') query = dict(query) start, end = query['time'] del query['time'] product_queries = list(self._get_product_queries(query)) if ensure_single: if len(product_queries) == 0: raise ValueError('No products match search terms: %r' % query) if len(product_queries) > 1: raise ValueError( 'Multiple products match single query search: %r' % ([dt.name for q, dt in product_queries], )) for q, product in product_queries: dataset_fields = product.metadata_type.dataset_fields query_exprs = tuple(fields.to_expressions(dataset_fields.get, **q)) with self._db.connect() as connection: yield product, list( connection.count_datasets_through_time( start, end, period, dataset_fields.get('time'), query_exprs))
def _do_count_by_product(self, query): product_queries = self._get_product_queries(query) for q, product in product_queries: dataset_fields = product.metadata_type.dataset_fields query_exprs = tuple(fields.to_expressions(dataset_fields.get, **q)) with self._db.connect() as connection: count = connection.count_datasets(query_exprs) if count > 0: yield product, count
def test_build_query_expressions(): assert [EqualsExpression(_sat_field, "LANDSAT_8")] == to_expressions(_fields.get, platform="LANDSAT_8") assert [ RangeBetweenExpression(_lat_field, 4, 23.0, _range_class=NumericRange) ] == to_expressions(_fields.get, lat=Range(4, 23))
def test_build_query_expressions(): assert [EqualsExpression(_sat_field, "LANDSAT_8")] == to_expressions(_fields.get, platform="LANDSAT_8") assert [ RangeBetweenExpression(_lat_field, 4, 23.0, _range_class=NumericRange) ] == to_expressions(_fields.get, lat=Range(4, 23))