"""
Implementation of reverse geocoding.
"""
-from typing import Optional, List
+from typing import Optional, List, Callable, Type, Tuple, Dict, Any, cast, Union
+import functools
import sqlalchemy as sa
-from geoalchemy2 import WKTElement
-from nominatim.typing import SaColumn, SaSelect, SaFromClause, SaLabel, SaRow
+from nominatim.typing import SaColumn, SaSelect, SaFromClause, SaLabel, SaRow,\
+ SaBind, SaLambdaSelect
from nominatim.api.connection import SearchConnection
import nominatim.api.results as nres
from nominatim.api.logging import log
-from nominatim.api.types import AnyPoint, DataLayer, LookupDetails, GeometryFormat
+from nominatim.api.types import AnyPoint, DataLayer, ReverseDetails, GeometryFormat, Bbox
+from nominatim.db.sqlalchemy_types import Geometry
+import nominatim.db.sqlalchemy_functions as snfn
# In SQLAlchemy expression which compare with NULL need to be expressed with
# the equal sign.
# pylint: disable=singleton-comparison
-def _select_from_placex(t: SaFromClause, wkt: Optional[str] = None) -> SaSelect:
+RowFunc = Callable[[Optional[SaRow], Type[nres.ReverseResult]], Optional[nres.ReverseResult]]
+
+WKT_PARAM: SaBind = sa.bindparam('wkt', type_=Geometry)
+MAX_RANK_PARAM: SaBind = sa.bindparam('max_rank')
+
+def no_index(expr: SaColumn) -> SaColumn:
+ """ Wrap the given expression, so that the query planner will
+ refrain from using the expression for index lookup.
+ """
+ return sa.func.coalesce(sa.null(), expr) # pylint: disable=not-callable
+
+
+def _select_from_placex(t: SaFromClause, use_wkt: bool = True) -> SaSelect:
""" Create a select statement with the columns relevant for reverse
results.
"""
- if wkt is None:
+ if not use_wkt:
distance = t.c.distance
+ centroid = t.c.centroid
else:
- distance = t.c.geometry.ST_Distance(wkt)
+ distance = t.c.geometry.ST_Distance(WKT_PARAM)
+ centroid = sa.case((t.c.geometry.is_line_like(), t.c.geometry.ST_ClosestPoint(WKT_PARAM)),
+ else_=t.c.centroid).label('centroid')
+
return sa.select(t.c.place_id, t.c.osm_type, t.c.osm_id, t.c.name,
t.c.class_, t.c.type,
t.c.housenumber, t.c.postcode, t.c.country_code,
t.c.importance, t.c.wikipedia,
t.c.parent_place_id, t.c.rank_address, t.c.rank_search,
- t.c.centroid,
+ centroid,
distance.label('distance'),
t.c.geometry.ST_Expand(0).label('bbox'))
sa.Integer).label('housenumber')
+def _interpolated_position(table: SaFromClause) -> SaLabel:
+ fac = sa.cast(table.c.step, sa.Float) / (table.c.endnumber - table.c.startnumber)
+ rounded_pos = sa.func.round(table.c.position / fac) * fac
+ return sa.case(
+ (table.c.endnumber == table.c.startnumber, table.c.linegeo.ST_Centroid()),
+ else_=table.c.linegeo.ST_LineInterpolatePoint(rounded_pos)).label('centroid')
+
+
+def _locate_interpolation(table: SaFromClause) -> SaLabel:
+ """ Given a position, locate the closest point on the line.
+ """
+ return sa.case((table.c.linegeo.is_line_like(),
+ table.c.linegeo.ST_LineLocatePoint(WKT_PARAM)),
+ else_=0).label('position')
+
+
def _is_address_point(table: SaFromClause) -> SaColumn:
return sa.and_(table.c.rank_address == 30,
sa.or_(table.c.housenumber != None,
- table.c.name.has_key('housename')))
+ table.c.name.has_key('addr:housename')))
+
def _get_closest(*rows: Optional[SaRow]) -> Optional[SaRow]:
return min(rows, key=lambda row: 1000 if row is None else row.distance)
+
class ReverseGeocoder:
""" Class implementing the logic for looking up a place from a
coordinate.
"""
- def __init__(self, conn: SearchConnection, max_rank: int, layer: DataLayer,
- details: LookupDetails) -> None:
+ def __init__(self, conn: SearchConnection, params: ReverseDetails) -> None:
self.conn = conn
- self.max_rank = max_rank
- self.layer = layer
- self.details = details
+ self.params = params
+
+ self.bind_params: Dict[str, Any] = {'max_rank': params.max_rank}
+
+
+ @property
+ def max_rank(self) -> int:
+ """ Return the maximum configured rank.
+ """
+ return self.params.max_rank
+
+
+ def has_geometries(self) -> bool:
+ """ Check if any geometries are requested.
+ """
+ return bool(self.params.geometry_output)
+
def layer_enabled(self, *layer: DataLayer) -> bool:
""" Return true when any of the given layer types are requested.
"""
- return any(self.layer & l for l in layer)
+ return any(self.params.layers & l for l in layer)
def layer_disabled(self, *layer: DataLayer) -> bool:
""" Return true when none of the given layer types is requested.
"""
- return not any(self.layer & l for l in layer)
+ return not any(self.params.layers & l for l in layer)
def has_feature_layers(self) -> bool:
"""
return self.layer_enabled(DataLayer.RAILWAY, DataLayer.MANMADE, DataLayer.NATURAL)
- def _add_geometry_columns(self, sql: SaSelect, col: SaColumn) -> SaSelect:
- if not self.details.geometry_output:
- return sql
+ def _add_geometry_columns(self, sql: SaLambdaSelect, col: SaColumn) -> SaSelect:
out = []
- if self.details.geometry_simplification > 0.0:
- col = col.ST_SimplifyPreserveTopology(self.details.geometry_simplification)
+ if self.params.geometry_simplification > 0.0:
+ col = sa.func.ST_SimplifyPreserveTopology(col, self.params.geometry_simplification)
- if self.details.geometry_output & GeometryFormat.GEOJSON:
- out.append(col.ST_AsGeoJSON().label('geometry_geojson'))
- if self.details.geometry_output & GeometryFormat.TEXT:
- out.append(col.ST_AsText().label('geometry_text'))
- if self.details.geometry_output & GeometryFormat.KML:
- out.append(col.ST_AsKML().label('geometry_kml'))
- if self.details.geometry_output & GeometryFormat.SVG:
- out.append(col.ST_AsSVG().label('geometry_svg'))
+ if self.params.geometry_output & GeometryFormat.GEOJSON:
+ out.append(sa.func.ST_AsGeoJSON(col).label('geometry_geojson'))
+ if self.params.geometry_output & GeometryFormat.TEXT:
+ out.append(sa.func.ST_AsText(col).label('geometry_text'))
+ if self.params.geometry_output & GeometryFormat.KML:
+ out.append(sa.func.ST_AsKML(col).label('geometry_kml'))
+ if self.params.geometry_output & GeometryFormat.SVG:
+ out.append(sa.func.ST_AsSVG(col).label('geometry_svg'))
return sql.add_columns(*out)
return table.c.class_.in_(tuple(include))
- async def _find_closest_street_or_poi(self, wkt: WKTElement,
- distance: float) -> Optional[SaRow]:
+ async def _find_closest_street_or_poi(self, distance: float) -> Optional[SaRow]:
""" Look up the closest rank 26+ place in the database, which
is closer than the given distance.
"""
t = self.conn.t.placex
- sql = _select_from_placex(t, wkt)\
- .where(t.c.geometry.ST_DWithin(wkt, distance))\
- .where(t.c.indexed_status == 0)\
- .where(t.c.linked_place_id == None)\
- .where(sa.or_(t.c.geometry.ST_GeometryType()
- .not_in(('ST_Polygon', 'ST_MultiPolygon')),
- t.c.centroid.ST_Distance(wkt) < distance))\
- .order_by('distance')\
- .limit(1)
-
- sql = self._add_geometry_columns(sql, t.c.geometry)
+ # PostgreSQL must not get the distance as a parameter because
+ # there is a danger it won't be able to proberly estimate index use
+ # when used with prepared statements
+ diststr = sa.text(f"{distance}")
+
+ sql: SaLambdaSelect = sa.lambda_stmt(lambda: _select_from_placex(t)
+ .where(t.c.geometry.ST_DWithin(WKT_PARAM, diststr))
+ .where(t.c.indexed_status == 0)
+ .where(t.c.linked_place_id == None)
+ .where(sa.or_(sa.not_(t.c.geometry.is_area()),
+ t.c.centroid.ST_Distance(WKT_PARAM) < diststr))
+ .order_by('distance')
+ .limit(1))
+
+ if self.has_geometries():
+ sql = self._add_geometry_columns(sql, t.c.geometry)
- restrict: List[SaColumn] = []
+ restrict: List[Union[SaColumn, Callable[[], SaColumn]]] = []
if self.layer_enabled(DataLayer.ADDRESS):
- restrict.append(sa.and_(t.c.rank_address >= 26,
- t.c.rank_address <= min(29, self.max_rank)))
+ max_rank = min(29, self.max_rank)
+ restrict.append(lambda: no_index(t.c.rank_address).between(26, max_rank))
if self.max_rank == 30:
- restrict.append(_is_address_point(t))
+ restrict.append(lambda: _is_address_point(t))
if self.layer_enabled(DataLayer.POI) and self.max_rank == 30:
- restrict.append(sa.and_(t.c.rank_search == 30,
- t.c.class_.not_in(('place', 'building')),
- t.c.geometry.ST_GeometryType() != 'ST_LineString'))
+ restrict.append(lambda: sa.and_(no_index(t.c.rank_search) == 30,
+ t.c.class_.not_in(('place', 'building')),
+ sa.not_(t.c.geometry.is_line_like())))
if self.has_feature_layers():
- restrict.append(sa.and_(t.c.rank_search.between(26, self.max_rank),
- t.c.rank_address == 0,
+ restrict.append(sa.and_(no_index(t.c.rank_search).between(26, MAX_RANK_PARAM),
+ no_index(t.c.rank_address) == 0,
self._filter_by_layer(t)))
if not restrict:
return None
- return (await self.conn.execute(sql.where(sa.or_(*restrict)))).one_or_none()
+ sql = sql.where(sa.or_(*restrict))
+
+ return (await self.conn.execute(sql, self.bind_params)).one_or_none()
- async def _find_housenumber_for_street(self, parent_place_id: int,
- wkt: WKTElement) -> Optional[SaRow]:
+ async def _find_housenumber_for_street(self, parent_place_id: int) -> Optional[SaRow]:
t = self.conn.t.placex
- sql = _select_from_placex(t, wkt)\
- .where(t.c.geometry.ST_DWithin(wkt, 0.001))\
- .where(t.c.parent_place_id == parent_place_id)\
- .where(_is_address_point(t))\
- .where(t.c.indexed_status == 0)\
- .where(t.c.linked_place_id == None)\
- .order_by('distance')\
- .limit(1)
+ sql: SaLambdaSelect = sa.lambda_stmt(lambda: _select_from_placex(t)
+ .where(t.c.geometry.ST_DWithin(WKT_PARAM, 0.001))
+ .where(t.c.parent_place_id == parent_place_id)
+ .where(_is_address_point(t))
+ .where(t.c.indexed_status == 0)
+ .where(t.c.linked_place_id == None)
+ .order_by('distance')
+ .limit(1))
- sql = self._add_geometry_columns(sql, t.c.geometry)
+ if self.has_geometries():
+ sql = self._add_geometry_columns(sql, t.c.geometry)
- return (await self.conn.execute(sql)).one_or_none()
+ return (await self.conn.execute(sql, self.bind_params)).one_or_none()
async def _find_interpolation_for_street(self, parent_place_id: Optional[int],
- wkt: WKTElement,
distance: float) -> Optional[SaRow]:
t = self.conn.t.osmline
- sql = sa.select(t,
- t.c.linegeo.ST_Distance(wkt).label('distance'),
- t.c.linegeo.ST_LineLocatePoint(wkt).label('position'))\
- .where(t.c.linegeo.ST_DWithin(wkt, distance))\
- .order_by('distance')\
- .limit(1)
+ sql: Any = sa.lambda_stmt(lambda:
+ sa.select(t,
+ t.c.linegeo.ST_Distance(WKT_PARAM).label('distance'),
+ _locate_interpolation(t))
+ .where(t.c.linegeo.ST_DWithin(WKT_PARAM, distance))
+ .where(t.c.startnumber != None)
+ .order_by('distance')
+ .limit(1))
if parent_place_id is not None:
- sql = sql.where(t.c.parent_place_id == parent_place_id)
+ sql += lambda s: s.where(t.c.parent_place_id == parent_place_id)
+
+ def _wrap_query(base_sql: SaLambdaSelect) -> SaSelect:
+ inner = base_sql.subquery('ipol')
- inner = sql.subquery()
+ return sa.select(inner.c.place_id, inner.c.osm_id,
+ inner.c.parent_place_id, inner.c.address,
+ _interpolated_housenumber(inner),
+ _interpolated_position(inner),
+ inner.c.postcode, inner.c.country_code,
+ inner.c.distance)
- sql = sa.select(inner.c.place_id, inner.c.osm_id,
- inner.c.parent_place_id, inner.c.address,
- _interpolated_housenumber(inner),
- inner.c.postcode, inner.c.country_code,
- inner.c.linegeo.ST_LineInterpolatePoint(inner.c.position).label('centroid'),
- inner.c.distance)
+ sql += _wrap_query
- if self.details.geometry_output:
- sub = sql.subquery()
- sql = self._add_geometry_columns(sql, sub.c.centroid)
+ if self.has_geometries():
+ sub = sql.subquery('geom')
+ sql = self._add_geometry_columns(sa.select(sub), sub.c.centroid)
- return (await self.conn.execute(sql)).one_or_none()
+ return (await self.conn.execute(sql, self.bind_params)).one_or_none()
- async def _find_tiger_number_for_street(self, parent_place_id: int,
- wkt: WKTElement) -> Optional[SaRow]:
+ async def _find_tiger_number_for_street(self, parent_place_id: int) -> Optional[SaRow]:
t = self.conn.t.tiger
- inner = sa.select(t,
- t.c.linegeo.ST_Distance(wkt).label('distance'),
- sa.func.ST_LineLocatePoint(t.c.linegeo, wkt).label('position'))\
- .where(t.c.linegeo.ST_DWithin(wkt, 0.001))\
- .where(t.c.parent_place_id == parent_place_id)\
- .order_by('distance')\
- .limit(1)\
- .subquery()
+ def _base_query() -> SaSelect:
+ inner = sa.select(t,
+ t.c.linegeo.ST_Distance(WKT_PARAM).label('distance'),
+ _locate_interpolation(t))\
+ .where(t.c.linegeo.ST_DWithin(WKT_PARAM, 0.001))\
+ .where(t.c.parent_place_id == parent_place_id)\
+ .order_by('distance')\
+ .limit(1)\
+ .subquery('tiger')
+
+ return sa.select(inner.c.place_id,
+ inner.c.parent_place_id,
+ _interpolated_housenumber(inner),
+ _interpolated_position(inner),
+ inner.c.postcode,
+ inner.c.distance)
- sql = sa.select(inner.c.place_id,
- inner.c.parent_place_id,
- _interpolated_housenumber(inner),
- inner.c.postcode,
- inner.c.linegeo.ST_LineInterpolatePoint(inner.c.position).label('centroid'),
- inner.c.distance)
+ sql: SaLambdaSelect = sa.lambda_stmt(_base_query)
- if self.details.geometry_output:
- sub = sql.subquery()
- sql = self._add_geometry_columns(sql, sub.c.centroid)
+ if self.has_geometries():
+ sub = sql.subquery('geom')
+ sql = self._add_geometry_columns(sa.select(sub), sub.c.centroid)
- return (await self.conn.execute(sql)).one_or_none()
+ return (await self.conn.execute(sql, self.bind_params)).one_or_none()
- async def lookup_street_poi(self, wkt: WKTElement) -> Optional[nres.ReverseResult]:
+ async def lookup_street_poi(self) -> Tuple[Optional[SaRow], RowFunc]:
""" Find a street or POI/address for the given WKT point.
"""
log().section('Reverse lookup on street/address level')
- result = None
distance = 0.006
parent_place_id = None
- row = await self._find_closest_street_or_poi(wkt, distance)
+ row = await self._find_closest_street_or_poi(distance)
+ row_func: RowFunc = nres.create_from_placex_row
log().var_dump('Result (street/building)', row)
# If the closest result was a street, but an address was requested,
distance = 0.001
parent_place_id = row.place_id
log().comment('Find housenumber for street')
- addr_row = await self._find_housenumber_for_street(parent_place_id, wkt)
+ addr_row = await self._find_housenumber_for_street(parent_place_id)
log().var_dump('Result (street housenumber)', addr_row)
if addr_row is not None:
row = addr_row
+ row_func = nres.create_from_placex_row
distance = addr_row.distance
elif row.country_code == 'us' and parent_place_id is not None:
log().comment('Find TIGER housenumber for street')
- addr_row = await self._find_tiger_number_for_street(parent_place_id, wkt)
+ addr_row = await self._find_tiger_number_for_street(parent_place_id)
log().var_dump('Result (street Tiger housenumber)', addr_row)
if addr_row is not None:
- result = nres.create_from_tiger_row(addr_row, nres.ReverseResult)
+ row_func = cast(RowFunc,
+ functools.partial(nres.create_from_tiger_row,
+ osm_type=row.osm_type,
+ osm_id=row.osm_id))
+ row = addr_row
else:
distance = row.distance
if self.max_rank > 27 and self.layer_enabled(DataLayer.ADDRESS):
log().comment('Find interpolation for street')
addr_row = await self._find_interpolation_for_street(parent_place_id,
- wkt, distance)
+ distance)
log().var_dump('Result (street interpolation)', addr_row)
if addr_row is not None:
- result = nres.create_from_osmline_row(addr_row, nres.ReverseResult)
+ row = addr_row
+ row_func = nres.create_from_osmline_row
- return result or nres.create_from_placex_row(row, nres.ReverseResult)
+ return row, row_func
- async def _lookup_area_address(self, wkt: WKTElement) -> Optional[SaRow]:
+ async def _lookup_area_address(self) -> Optional[SaRow]:
""" Lookup large addressable areas for the given WKT point.
"""
log().comment('Reverse lookup by larger address area features')
t = self.conn.t.placex
- # The inner SQL brings results in the right order, so that
- # later only a minimum of results needs to be checked with ST_Contains.
- inner = sa.select(t, sa.literal(0.0).label('distance'))\
- .where(t.c.rank_search.between(5, self.max_rank))\
- .where(t.c.rank_address.between(5, 25))\
- .where(t.c.geometry.ST_GeometryType().in_(('ST_Polygon', 'ST_MultiPolygon')))\
- .where(t.c.geometry.intersects(wkt))\
- .where(t.c.name != None)\
- .where(t.c.indexed_status == 0)\
- .where(t.c.linked_place_id == None)\
- .where(t.c.type != 'postcode')\
- .order_by(sa.desc(t.c.rank_search))\
- .limit(50)\
- .subquery()
+ def _base_query() -> SaSelect:
+ # The inner SQL brings results in the right order, so that
+ # later only a minimum of results needs to be checked with ST_Contains.
+ inner = sa.select(t, sa.literal(0.0).label('distance'))\
+ .where(t.c.rank_search.between(5, MAX_RANK_PARAM))\
+ .where(t.c.geometry.intersects(WKT_PARAM))\
+ .where(snfn.select_index_placex_geometry_reverse_lookuppolygon('placex'))\
+ .order_by(sa.desc(t.c.rank_search))\
+ .limit(50)\
+ .subquery('area')
- sql = _select_from_placex(inner)\
- .where(inner.c.geometry.ST_Contains(wkt))\
- .order_by(sa.desc(inner.c.rank_search))\
- .limit(1)
+ return _select_from_placex(inner, False)\
+ .where(inner.c.geometry.ST_Contains(WKT_PARAM))\
+ .order_by(sa.desc(inner.c.rank_search))\
+ .limit(1)
- sql = self._add_geometry_columns(sql, inner.c.geometry)
+ sql: SaLambdaSelect = sa.lambda_stmt(_base_query)
+ if self.has_geometries():
+ sql = self._add_geometry_columns(sql, sa.literal_column('area.geometry'))
- address_row = (await self.conn.execute(sql)).one_or_none()
+ address_row = (await self.conn.execute(sql, self.bind_params)).one_or_none()
log().var_dump('Result (area)', address_row)
if address_row is not None and address_row.rank_search < self.max_rank:
log().comment('Search for better matching place nodes inside the area')
- inner = sa.select(t,
- t.c.geometry.ST_Distance(wkt).label('distance'))\
- .where(t.c.osm_type == 'N')\
- .where(t.c.rank_search > address_row.rank_search)\
- .where(t.c.rank_search <= self.max_rank)\
- .where(t.c.rank_address.between(5, 25))\
- .where(t.c.name != None)\
+
+ address_rank = address_row.rank_search
+ address_id = address_row.place_id
+
+ def _place_inside_area_query() -> SaSelect:
+ inner = \
+ sa.select(t,
+ t.c.geometry.ST_Distance(WKT_PARAM).label('distance'))\
+ .where(t.c.rank_search > address_rank)\
+ .where(t.c.rank_search <= MAX_RANK_PARAM)\
.where(t.c.indexed_status == 0)\
- .where(t.c.linked_place_id == None)\
- .where(t.c.type != 'postcode')\
+ .where(snfn.select_index_placex_geometry_reverse_lookupplacenode('placex'))\
.where(t.c.geometry
.ST_Buffer(sa.func.reverse_place_diameter(t.c.rank_search))
- .intersects(wkt))\
+ .intersects(WKT_PARAM))\
.order_by(sa.desc(t.c.rank_search))\
.limit(50)\
- .subquery()
+ .subquery('places')
- touter = self.conn.t.placex.alias('outer')
- sql = _select_from_placex(inner)\
- .join(touter, touter.c.geometry.ST_Contains(inner.c.geometry))\
- .where(touter.c.place_id == address_row.place_id)\
- .where(inner.c.distance < sa.func.reverse_place_diameter(inner.c.rank_search))\
- .order_by(sa.desc(inner.c.rank_search), inner.c.distance)\
- .limit(1)
+ touter = t.alias('outer')
+ return _select_from_placex(inner, False)\
+ .join(touter, touter.c.geometry.ST_Contains(inner.c.geometry))\
+ .where(touter.c.place_id == address_id)\
+ .where(inner.c.distance < sa.func.reverse_place_diameter(inner.c.rank_search))\
+ .order_by(sa.desc(inner.c.rank_search), inner.c.distance)\
+ .limit(1)
- sql = self._add_geometry_columns(sql, inner.c.geometry)
+ sql = sa.lambda_stmt(_place_inside_area_query)
+ if self.has_geometries():
+ sql = self._add_geometry_columns(sql, sa.literal_column('places.geometry'))
- place_address_row = (await self.conn.execute(sql)).one_or_none()
+ place_address_row = (await self.conn.execute(sql, self.bind_params)).one_or_none()
log().var_dump('Result (place node)', place_address_row)
if place_address_row is not None:
return address_row
- async def _lookup_area_others(self, wkt: WKTElement) -> Optional[SaRow]:
+ async def _lookup_area_others(self) -> Optional[SaRow]:
t = self.conn.t.placex
- inner = sa.select(t, t.c.geometry.ST_Distance(wkt).label('distance'))\
+ inner = sa.select(t, t.c.geometry.ST_Distance(WKT_PARAM).label('distance'))\
.where(t.c.rank_address == 0)\
- .where(t.c.rank_search.between(5, self.max_rank))\
+ .where(t.c.rank_search.between(5, MAX_RANK_PARAM))\
.where(t.c.name != None)\
.where(t.c.indexed_status == 0)\
.where(t.c.linked_place_id == None)\
.where(self._filter_by_layer(t))\
.where(t.c.geometry
.ST_Buffer(sa.func.reverse_place_diameter(t.c.rank_search))
- .intersects(wkt))\
+ .intersects(WKT_PARAM))\
.order_by(sa.desc(t.c.rank_search))\
.limit(50)\
.subquery()
- sql = _select_from_placex(inner)\
- .where(sa.or_(inner.c.geometry.ST_GeometryType()
- .not_in(('ST_Polygon', 'ST_MultiPolygon')),
- inner.c.geometry.ST_Contains(wkt)))\
+ sql = _select_from_placex(inner, False)\
+ .where(sa.or_(sa.not_(inner.c.geometry.is_area()),
+ inner.c.geometry.ST_Contains(WKT_PARAM)))\
.order_by(sa.desc(inner.c.rank_search), inner.c.distance)\
.limit(1)
- sql = self._add_geometry_columns(sql, inner.c.geometry)
+ if self.has_geometries():
+ sql = self._add_geometry_columns(sql, inner.c.geometry)
- row = (await self.conn.execute(sql)).one_or_none()
+ row = (await self.conn.execute(sql, self.bind_params)).one_or_none()
log().var_dump('Result (non-address feature)', row)
return row
- async def lookup_area(self, wkt: WKTElement) -> Optional[nres.ReverseResult]:
- """ Lookup large areas for the given WKT point.
+ async def lookup_area(self) -> Optional[SaRow]:
+ """ Lookup large areas for the current search.
"""
log().section('Reverse lookup by larger area features')
if self.layer_enabled(DataLayer.ADDRESS):
- address_row = await self._lookup_area_address(wkt)
+ address_row = await self._lookup_area_address()
else:
address_row = None
if self.has_feature_layers():
- other_row = await self._lookup_area_others(wkt)
+ other_row = await self._lookup_area_others()
else:
other_row = None
- return nres.create_from_placex_row(_get_closest(address_row, other_row), nres.ReverseResult)
+ return _get_closest(address_row, other_row)
- async def lookup_country(self, wkt: WKTElement) -> Optional[nres.ReverseResult]:
- """ Lookup the country for the given WKT point.
+ async def lookup_country(self) -> Optional[SaRow]:
+ """ Lookup the country for the current search.
"""
log().section('Reverse lookup by country code')
t = self.conn.t.country_grid
- sql = sa.select(t.c.country_code).distinct()\
- .where(t.c.geometry.ST_Contains(wkt))
+ sql: SaLambdaSelect = sa.select(t.c.country_code).distinct()\
+ .where(t.c.geometry.ST_Contains(WKT_PARAM))
- ccodes = tuple((r[0] for r in await self.conn.execute(sql)))
+ ccodes = tuple((r[0] for r in await self.conn.execute(sql, self.bind_params)))
log().var_dump('Country codes', ccodes)
if not ccodes:
if self.max_rank > 4:
log().comment('Search for place nodes in country')
- inner = sa.select(t,
- t.c.geometry.ST_Distance(wkt).label('distance'))\
- .where(t.c.osm_type == 'N')\
+ def _base_query() -> SaSelect:
+ inner = \
+ sa.select(t,
+ t.c.geometry.ST_Distance(WKT_PARAM).label('distance'))\
.where(t.c.rank_search > 4)\
- .where(t.c.rank_search <= self.max_rank)\
- .where(t.c.rank_address.between(5, 25))\
- .where(t.c.name != None)\
+ .where(t.c.rank_search <= MAX_RANK_PARAM)\
.where(t.c.indexed_status == 0)\
- .where(t.c.linked_place_id == None)\
- .where(t.c.type != 'postcode')\
.where(t.c.country_code.in_(ccodes))\
+ .where(snfn.select_index_placex_geometry_reverse_lookupplacenode('placex'))\
.where(t.c.geometry
.ST_Buffer(sa.func.reverse_place_diameter(t.c.rank_search))
- .intersects(wkt))\
+ .intersects(WKT_PARAM))\
.order_by(sa.desc(t.c.rank_search))\
.limit(50)\
- .subquery()
+ .subquery('area')
- sql = _select_from_placex(inner)\
- .where(inner.c.distance < sa.func.reverse_place_diameter(inner.c.rank_search))\
- .order_by(sa.desc(inner.c.rank_search), inner.c.distance)\
- .limit(1)
+ return _select_from_placex(inner, False)\
+ .where(inner.c.distance < sa.func.reverse_place_diameter(inner.c.rank_search))\
+ .order_by(sa.desc(inner.c.rank_search), inner.c.distance)\
+ .limit(1)
- sql = self._add_geometry_columns(sql, inner.c.geometry)
+ sql = sa.lambda_stmt(_base_query)
+ if self.has_geometries():
+ sql = self._add_geometry_columns(sql, sa.literal_column('area.geometry'))
- address_row = (await self.conn.execute(sql)).one_or_none()
+ address_row = (await self.conn.execute(sql, self.bind_params)).one_or_none()
log().var_dump('Result (addressable place node)', address_row)
else:
address_row = None
if address_row is None:
# Still nothing, then return a country with the appropriate country code.
- sql = _select_from_placex(t, wkt)\
+ sql = sa.lambda_stmt(lambda: _select_from_placex(t)\
.where(t.c.country_code.in_(ccodes))\
.where(t.c.rank_address == 4)\
.where(t.c.rank_search == 4)\
.where(t.c.linked_place_id == None)\
- .order_by('distance')
+ .order_by('distance')\
+ .limit(1))
- sql = self._add_geometry_columns(sql, t.c.geometry)
+ if self.has_geometries():
+ sql = self._add_geometry_columns(sql, t.c.geometry)
- address_row = (await self.conn.execute(sql)).one_or_none()
+ address_row = (await self.conn.execute(sql, self.bind_params)).one_or_none()
- return nres.create_from_placex_row(address_row, nres.ReverseResult)
+ return address_row
async def lookup(self, coord: AnyPoint) -> Optional[nres.ReverseResult]:
""" Look up a single coordinate. Returns the place information,
if a place was found near the coordinates or None otherwise.
"""
- log().function('reverse_lookup',
- coord=coord, max_rank=self.max_rank,
- layer=self.layer, details=self.details)
+ log().function('reverse_lookup', coord=coord, params=self.params)
- wkt = WKTElement(f'POINT({coord[0]} {coord[1]})', srid=4326)
+ self.bind_params['wkt'] = f'POINT({coord[0]} {coord[1]})'
- result: Optional[nres.ReverseResult] = None
+ row: Optional[SaRow] = None
+ row_func: RowFunc = nres.create_from_placex_row
if self.max_rank >= 26:
- result = await self.lookup_street_poi(wkt)
- if result is None and self.max_rank > 4:
- result = await self.lookup_area(wkt)
- if result is None and self.layer_enabled(DataLayer.ADDRESS):
- result = await self.lookup_country(wkt)
+ row, tmp_row_func = await self.lookup_street_poi()
+ if row is not None:
+ row_func = tmp_row_func
+ if row is None and self.max_rank > 4:
+ row = await self.lookup_area()
+ if row is None and self.layer_enabled(DataLayer.ADDRESS):
+ row = await self.lookup_country()
+
+ result = row_func(row, nres.ReverseResult)
if result is not None:
- await nres.add_result_details(self.conn, result, self.details)
+ assert row is not None
+ result.distance = row.distance
+ if hasattr(row, 'bbox'):
+ result.bbox = Bbox.from_wkb(row.bbox)
+ await nres.add_result_details(self.conn, [result], self.params)
return result
projects / nominatim.git / blobdiff