def make_select_fields(self, product, field_names, custom_offsets):
"""
Parse and generate the list of select fields to be passed to the database API.
"""
assert product and field_names
dataset_fields = product.metadata_type.dataset_fields
dataset_section = product.metadata_type.definition['dataset']
select_fields = []
for field_name in field_names:
if dataset_fields.get(field_name):
select_fields.append(dataset_fields[field_name])
else:
# try to construct the field
if field_name in {'transform', 'extent', 'crs', 'bounds'}:
grid_spatial = dataset_section.get('grid_spatial')
if grid_spatial:
select_fields.append(SimpleDocField(
'grid_spatial', 'grid_spatial', DATASET.c.metadata,
False,
offset=grid_spatial
))
elif custom_offsets and field_name in custom_offsets:
select_fields.append(SimpleDocField(
field_name, field_name, DATASET.c.metadata,
False,
offset=custom_offsets[field_name]
))
elif field_name == 'uris':
select_fields.append(Field('uris', 'uris'))
return select_fields
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 test_get_single_field():
fields = parse_fields({
'platform': {
'description': 'Satellite',
'offset': ['platform', 'code']
},
'instrument': {
'offset': ['instrument', 'name']
}
}, DATASET.c.metadata)
assert set(fields.keys()) == {'platform', 'instrument'}
field = fields['platform']
_assert_same(
field,
SimpleDocField(
'platform', 'Satellite',
DATASET.c.metadata,
True,
offset=['platform', 'code']
)
)
assert isinstance(field, SimpleDocField)
assert field.extract({'platform': {'code': 'turtle'}}) == 'turtle'
assert field.extract({'platform': {'code': None}}) is None
assert field.extract({}) is None
def get_custom_query_expressions(self, custom_query, custom_offsets):
"""
Generate query expressions for custom fields. it is assumed that custom fields are to be found
in metadata doc and their offsets are provided. custom_query is a dict of key fields involving
custom fields.
"""
custom_exprs = []
for key in custom_query:
# for now we assume all custom query fields are SimpleDocFields
custom_field = SimpleDocField(
custom_query[key], custom_query[key], DATASET.c.metadata,
False, offset=custom_offsets[key]
)
custom_exprs.append(fields.as_expression(custom_field, custom_query[key]))
return custom_exprs
Module
"""
from __future__ import absolute_import
from datetime import datetime
from dateutil.tz.tz import tzutc
from psycopg2.extras import NumericRange
from datacube.index.fields import to_expressions
from datacube.drivers.postgres._fields import SimpleDocField, RangeBetweenExpression, EqualsExpression, \
NumericRangeDocField
from datacube.model import Range
from datacube.ui import parse_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
}
def test_parse_simple_expression():
assert {'platform': 4} == parse_expressions('platform = 4')
assert {'platform': 'LANDSAT_8'} == parse_expressions('platform = "LANDSAT_8"')
assert {'platform': 'LANDSAT_8'} == parse_expressions('platform = LANDSAT_8')
assert {'platform': 'LAND SAT_8'} == parse_expressions('platform = "LAND SAT_8"')