lib-sql/functions/ranking.sql

   1 -- SPDX-License-Identifier: GPL-2.0-only
   2 --
   3 -- This file is part of Nominatim. (https://nominatim.org)
   4 --
   5 -- Copyright (C) 2022 by the Nominatim developer community.
   6 -- For a full list of authors see the git log.
   7
   8 -- Functions related to search and address ranks
   9
  10 -- Return an approximate search radius according to the search rank.
  11 CREATE OR REPLACE FUNCTION reverse_place_diameter(rank_search SMALLINT)
  12   RETURNS FLOAT
  13   AS $$
  14 BEGIN
  15   IF rank_search <= 4 THEN
  16     RETURN 5.0;
  17   ELSIF rank_search <= 8 THEN
  18     RETURN 1.8;
  19   ELSIF rank_search <= 12 THEN
  20     RETURN 0.6;
  21   ELSIF rank_search <= 17 THEN
  22     RETURN 0.16;
  23   ELSIF rank_search <= 18 THEN
  24     RETURN 0.08;
  25   ELSIF rank_search <= 19 THEN
  26     RETURN 0.04;
  27   END IF;
  28
  29   RETURN 0.02;
  30 END;
  31 $$
  32 LANGUAGE plpgsql IMMUTABLE PARALLEL SAFE;
  33
  34
  35 -- Return an approximate update radius according to the search rank.
  36 CREATE OR REPLACE FUNCTION update_place_diameter(rank_search SMALLINT)
  37   RETURNS FLOAT
  38   AS $$
  39 BEGIN
  40   -- postcodes
  41   IF rank_search = 11 or rank_search = 5 THEN
  42     RETURN 0.05;
  43   -- anything higher than city is effectively ignored (polygon required)
  44   ELSIF rank_search < 16 THEN
  45     RETURN 0;
  46   ELSIF rank_search < 18 THEN
  47     RETURN 0.1;
  48   ELSIF rank_search < 20 THEN
  49     RETURN 0.05;
  50   ELSIF rank_search = 21 THEN
  51     RETURN 0.001;
  52   ELSIF rank_search < 24 THEN
  53     RETURN 0.02;
  54   ELSIF rank_search < 26 THEN
  55     RETURN 0.002;
  56   ELSIF rank_search < 28 THEN
  57     RETURN 0.001;
  58   END IF;
  59
  60   RETURN 0;
  61 END;
  62 $$
  63 LANGUAGE plpgsql IMMUTABLE PARALLEL SAFE;
  64
  65 -- Compute a base address rank from the extent of the given geometry.
  66 --
  67 -- This is all simple guess work. We don't need particularly good estimates
  68 -- here. This just avoids to have very high ranked address parts in features
  69 -- that span very large areas (or vice versa).
  70 CREATE OR REPLACE FUNCTION geometry_to_rank(search_rank SMALLINT, geometry GEOMETRY, country_code TEXT)
  71   RETURNS SMALLINT
  72   AS $$
  73 DECLARE
  74   area FLOAT;
  75 BEGIN
  76   IF ST_GeometryType(geometry) in ('ST_Polygon','ST_MultiPolygon') THEN
  77       area := ST_Area(geometry);
  78   ELSIF ST_GeometryType(geometry) in ('ST_LineString','ST_MultiLineString') THEN
  79       area := (ST_Length(geometry)^2) * 0.1;
  80   ELSE
  81     RETURN search_rank;
  82   END IF;
  83
  84   -- adjust for the fact that countries come in different sizes
  85   IF country_code IN ('ca', 'au', 'ru') THEN
  86     area := area / 5;
  87   ELSIF country_code IN ('br', 'kz', 'cn', 'us', 'ne', 'gb', 'za', 'sa', 'id', 'eh', 'ml', 'tm') THEN
  88     area := area / 3;
  89   ELSIF country_code IN ('bo', 'ar', 'sd', 'mn', 'in', 'et', 'cd', 'mz', 'ly', 'cl', 'zm') THEN
  90     area := area / 2;
  91   ELSIF country_code IN ('sg', 'ws', 'st', 'kn') THEN
  92     area := area * 5;
  93   ELSIF country_code IN ('dm', 'mt', 'lc', 'gg', 'sc', 'nr') THEN
  94     area := area * 20;
  95   END IF;
  96
  97   IF area > 1 THEN
  98     RETURN 7;
  99   ELSIF area > 0.1 THEN
 100     RETURN 9;
 101   ELSIF area > 0.01 THEN
 102     RETURN 13;
 103   ELSIF area > 0.001 THEN
 104     RETURN 17;
 105   ELSIF area > 0.0001 THEN
 106     RETURN 19;
 107   ELSIF area > 0.000005 THEN
 108     RETURN 21;
 109   END IF;
 110
 111    RETURN 23;
 112 END;
 113 $$
 114 LANGUAGE plpgsql IMMUTABLE PARALLEL SAFE;
 115
 116
 117 -- Guess a ranking for postcodes from country and postcode format.
 118 CREATE OR REPLACE FUNCTION get_postcode_rank(country_code VARCHAR(2), postcode TEXT,
 119                                              OUT rank_search SMALLINT,
 120                                              OUT rank_address SMALLINT)
 121 AS $$
 122 DECLARE
 123   part TEXT;
 124 BEGIN
 125     rank_search := 30;
 126     rank_address := 30;
 127     postcode := upper(postcode);
 128
 129     IF country_code = 'gb' THEN
 130         IF postcode ~ '^([A-Z][A-Z]?[0-9][0-9A-Z]? [0-9][A-Z][A-Z])$' THEN
 131             rank_search := 25;
 132             rank_address := 5;
 133         ELSEIF postcode ~ '^([A-Z][A-Z]?[0-9][0-9A-Z]? [0-9])$' THEN
 134             rank_search := 23;
 135             rank_address := 5;
 136         ELSEIF postcode ~ '^([A-Z][A-Z]?[0-9][0-9A-Z])$' THEN
 137             rank_search := 21;
 138             rank_address := 5;
 139         END IF;
 140
 141     ELSEIF country_code = 'sg' THEN
 142         IF postcode ~ '^([0-9]{6})$' THEN
 143             rank_search := 25;
 144             rank_address := 11;
 145         END IF;
 146
 147     ELSEIF country_code = 'de' THEN
 148         IF postcode ~ '^([0-9]{5})$' THEN
 149             rank_search := 21;
 150             rank_address := 11;
 151         END IF;
 152
 153     ELSE
 154         -- Guess at the postcode format and coverage (!)
 155         IF postcode ~ '^[A-Z0-9]{1,5}$' THEN -- Probably too short to be very local
 156             rank_search := 21;
 157             rank_address := 11;
 158         ELSE
 159             -- Does it look splitable into and area and local code?
 160             part := substring(postcode from '^([- :A-Z0-9]+)([- :][A-Z0-9]+)$');
 161
 162             IF part IS NOT NULL THEN
 163                 rank_search := 25;
 164                 rank_address := 11;
 165             ELSEIF postcode ~ '^[- :A-Z0-9]{6,}$' THEN
 166                 rank_search := 21;
 167                 rank_address := 11;
 168             END IF;
 169         END IF;
 170     END IF;
 171
 172 END;
 173 $$
 174 LANGUAGE plpgsql IMMUTABLE PARALLEL SAFE;
 175
 176
 177 -- Get standard search and address rank for an object.
 178 --
 179 -- \param country        Two-letter country code where the object is in.
 180 -- \param extended_type  OSM type (N, W, R) or area type (A).
 181 -- \param place_class    Class (or tag key) of object.
 182 -- \param place_type     Type (or tag value) of object.
 183 -- \param admin_level    Value of admin_level tag.
 184 -- \param is_major       If true, boost search rank by one.
 185 -- \param postcode       Value of addr:postcode tag.
 186 -- \param[out] search_rank   Computed search rank.
 187 -- \param[out] address_rank  Computed address rank.
 188 --
 189 CREATE OR REPLACE FUNCTION compute_place_rank(country VARCHAR(2),
 190                                               extended_type VARCHAR(1),
 191                                               place_class TEXT, place_type TEXT,
 192                                               admin_level SMALLINT,
 193                                               is_major BOOLEAN,
 194                                               postcode TEXT,
 195                                               OUT search_rank SMALLINT,
 196                                               OUT address_rank SMALLINT)
 197 AS $$
 198 DECLARE
 199   classtype TEXT;
 200 BEGIN
 201   IF place_class in ('place','boundary')
 202      and place_type in ('postcode','postal_code')
 203   THEN
 204     SELECT * INTO search_rank, address_rank
 205       FROM get_postcode_rank(country, postcode);
 206   ELSEIF extended_type = 'N' AND place_class = 'highway' THEN
 207     search_rank = 30;
 208     address_rank = 30;
 209   ELSEIF place_class = 'landuse' AND extended_type != 'A' THEN
 210     search_rank = 30;
 211     address_rank = 30;
 212   ELSE
 213     IF place_class = 'boundary' and place_type = 'administrative' THEN
 214       classtype = place_type || admin_level::TEXT;
 215     ELSE
 216       classtype = place_type;
 217     END IF;
 218
 219     SELECT l.rank_search, l.rank_address INTO search_rank, address_rank
 220       FROM address_levels l
 221      WHERE (l.country_code = country or l.country_code is NULL)
 222            AND l.class = place_class AND (l.type = classtype or l.type is NULL)
 223      ORDER BY l.country_code, l.class, l.type LIMIT 1;
 224
 225     IF search_rank is NULL OR address_rank is NULL THEN
 226       search_rank := 30;
 227       address_rank := 30;
 228     END IF;
 229
 230     -- some postcorrections
 231     IF place_class = 'waterway' AND extended_type = 'R' THEN
 232         -- Slightly promote waterway relations so that they are processed
 233         -- before their members.
 234         search_rank := search_rank - 1;
 235     END IF;
 236
 237     IF is_major THEN
 238       search_rank := search_rank - 1;
 239     END IF;
 240   END IF;
 241 END;
 242 $$
 243 LANGUAGE plpgsql IMMUTABLE PARALLEL SAFE;
 244
 245 CREATE OR REPLACE FUNCTION get_addr_tag_rank(key TEXT, country TEXT,
 246                                              OUT from_rank SMALLINT,
 247                                              OUT to_rank SMALLINT,
 248                                              OUT extent FLOAT)
 249   AS $$
 250 DECLARE
 251   ranks RECORD;
 252 BEGIN
 253   from_rank := null;
 254
 255   FOR ranks IN
 256     SELECT * FROM
 257       (SELECT l.rank_search, l.rank_address FROM address_levels l
 258         WHERE (l.country_code = country or l.country_code is NULL)
 259                AND l.class = 'place' AND l.type = key
 260         ORDER BY l.country_code LIMIT 1) r
 261       WHERE rank_address > 0
 262   LOOP
 263     extent := reverse_place_diameter(ranks.rank_search);
 264
 265     IF ranks.rank_address <= 4 THEN
 266         from_rank := 4;
 267         to_rank := 4;
 268     ELSEIF ranks.rank_address <= 9 THEN
 269         from_rank := 5;
 270         to_rank := 9;
 271     ELSEIF ranks.rank_address <= 12 THEN
 272         from_rank := 10;
 273         to_rank := 12;
 274     ELSEIF ranks.rank_address <= 16 THEN
 275         from_rank := 13;
 276         to_rank := 16;
 277     ELSEIF ranks.rank_address <= 21 THEN
 278         from_rank := 17;
 279         to_rank := 21;
 280     ELSEIF ranks.rank_address <= 24 THEN
 281         from_rank := 22;
 282         to_rank := 24;
 283     ELSE
 284         from_rank := 25;
 285         to_rank := 25;
 286     END IF;
 287   END LOOP;
 288 END;
 289 $$
 290 LANGUAGE plpgsql IMMUTABLE PARALLEL SAFE;
 291
 292
 293 CREATE OR REPLACE FUNCTION weigh_search(search_vector INT[],
 294                                         rankings TEXT,
 295                                         def_weight FLOAT)
 296   RETURNS FLOAT
 297   AS $$
 298 DECLARE
 299   rank JSON;
 300 BEGIN
 301   FOR rank IN
 302     SELECT * FROM json_array_elements(rankings::JSON)
 303   LOOP
 304     IF true = ALL(SELECT x::int = ANY(search_vector) FROM json_array_elements_text(rank->1) as x) THEN
 305       RETURN (rank->>0)::float;
 306     END IF;
 307   END LOOP;
 308   RETURN def_weight;
 309 END;
 310 $$
 311 LANGUAGE plpgsql IMMUTABLE PARALLEL SAFE;