lib-sql/functions/partition-functions.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 DROP TYPE IF EXISTS nearfeaturecentr CASCADE;
   9 CREATE TYPE nearfeaturecentr AS (
  10   place_id BIGINT,
  11   keywords int[],
  12   rank_address smallint,
  13   rank_search smallint,
  14   distance float,
  15   isguess boolean,
  16   postcode TEXT,
  17   centroid GEOMETRY
  18 );
  19
  20 CREATE OR REPLACE function getNearFeatures(in_partition INTEGER, feature GEOMETRY,
  21                                            feature_centroid GEOMETRY,
  22                                            maxrank INTEGER)
  23 RETURNS setof nearfeaturecentr AS $$
  24 DECLARE
  25   r nearfeaturecentr%rowtype;
  26 BEGIN
  27
  28 {% for partition in db.partitions %}
  29   IF in_partition = {{ partition }} THEN
  30     FOR r IN
  31       SELECT place_id, keywords, rank_address, rank_search,
  32              CASE WHEN isguess THEN ST_Distance(feature, centroid)
  33                   ELSE min(ST_Distance(feature_centroid, geometry))
  34                        -- tie breaker when distance is the same (i.e. way is on boundary)
  35                        + 0.00001 * ST_Distance(feature, centroid)
  36              END as distance,
  37              isguess, postcode, centroid
  38       FROM location_area_large_{{ partition }}
  39       WHERE geometry && feature
  40         AND CASE WHEN ST_Dimension(feature) = 0
  41                      THEN _ST_Covers(geometry, feature)
  42                  WHEN ST_Dimension(feature) = 2
  43                      THEN ST_Relate(geometry, feature, 'T********')
  44                  ELSE ST_NPoints(ST_Intersection(geometry, feature)) > 1
  45             END
  46         AND rank_address < maxrank
  47             -- Postcodes currently still use rank_search to define for which
  48             -- features they are relevant.
  49         AND not (rank_address in (5, 11) and rank_search > maxrank)
  50       GROUP BY place_id, keywords, rank_address, rank_search, isguess, postcode, centroid
  51     LOOP
  52       RETURN NEXT r;
  53     END LOOP;
  54     RETURN;
  55   END IF;
  56 {% endfor %}
  57
  58   RAISE EXCEPTION 'Unknown partition %', in_partition;
  59 END
  60 $$
  61 LANGUAGE plpgsql STABLE PARALLEL SAFE;
  62
  63
  64 CREATE OR REPLACE FUNCTION get_address_place(in_partition SMALLINT, feature GEOMETRY,
  65                                              from_rank SMALLINT, to_rank SMALLINT,
  66                                              extent FLOAT, token_info JSONB, key TEXT)
  67   RETURNS nearfeaturecentr
  68   AS $$
  69 DECLARE
  70   r nearfeaturecentr%rowtype;
  71 BEGIN
  72 {% for partition in db.partitions %}
  73   IF in_partition = {{ partition }} THEN
  74       SELECT place_id, keywords, rank_address, rank_search,
  75              min(ST_Distance(feature, centroid)) as distance,
  76              isguess, postcode, centroid INTO r
  77         FROM location_area_large_{{ partition }}
  78         WHERE geometry && ST_Expand(feature, extent)
  79               AND rank_address between from_rank and to_rank
  80               AND token_matches_address(token_info, key, keywords)
  81         GROUP BY place_id, keywords, rank_address, rank_search, isguess, postcode, centroid
  82         ORDER BY bool_or(ST_Intersects(geometry, feature)) DESC, distance LIMIT 1;
  83       RETURN r;
  84   END IF;
  85 {% endfor %}
  86
  87   RAISE EXCEPTION 'Unknown partition %', in_partition;
  88 END;
  89 $$
  90 LANGUAGE plpgsql STABLE PARALLEL SAFE;
  91
  92
  93 create or replace function deleteLocationArea(in_partition INTEGER, in_place_id BIGINT, in_rank_search INTEGER) RETURNS BOOLEAN AS $$
  94 DECLARE
  95 BEGIN
  96
  97   IF in_rank_search <= 4 THEN
  98     DELETE from location_area_country WHERE place_id = in_place_id;
  99     RETURN TRUE;
 100   END IF;
 101
 102 {% for partition in db.partitions %}
 103   IF in_partition = {{ partition }} THEN
 104     DELETE from location_area_large_{{ partition }} WHERE place_id = in_place_id;
 105     RETURN TRUE;
 106   END IF;
 107 {% endfor %}
 108
 109   RAISE EXCEPTION 'Unknown partition %', in_partition;
 110
 111   RETURN FALSE;
 112 END
 113 $$
 114 LANGUAGE plpgsql;
 115
 116 create or replace function insertLocationAreaLarge(
 117   in_partition INTEGER, in_place_id BIGINT, in_country_code VARCHAR(2), in_keywords INTEGER[],
 118   in_rank_search INTEGER, in_rank_address INTEGER, in_estimate BOOLEAN, postcode TEXT,
 119   in_centroid GEOMETRY, in_geometry GEOMETRY) RETURNS BOOLEAN AS $$
 120 DECLARE
 121 BEGIN
 122   IF in_rank_address = 0 THEN
 123     RETURN TRUE;
 124   END IF;
 125
 126   IF in_rank_search <= 4 THEN
 127     IF not in_estimate and in_country_code is not NULL THEN
 128       INSERT INTO location_area_country (place_id, country_code, geometry)
 129         (SELECT in_place_id, in_country_code, geom
 130          FROM split_geometry(in_geometry) as geom);
 131     END IF;
 132     RETURN TRUE;
 133   END IF;
 134
 135 {% for partition in db.partitions %}
 136   IF in_partition = {{ partition }} THEN
 137     INSERT INTO location_area_large_{{ partition }} (partition, place_id, country_code, keywords, rank_search, rank_address, isguess, postcode, centroid, geometry)
 138       (SELECT in_partition, in_place_id, in_country_code, in_keywords, in_rank_search, in_rank_address, in_estimate, postcode, in_centroid, geom
 139        FROM split_geometry(in_geometry) as geom);
 140     RETURN TRUE;
 141   END IF;
 142 {% endfor %}
 143
 144   RAISE EXCEPTION 'Unknown partition %', in_partition;
 145   RETURN FALSE;
 146 END
 147 $$
 148 LANGUAGE plpgsql;
 149
 150 CREATE OR REPLACE FUNCTION getNearestNamedRoadPlaceId(in_partition INTEGER,
 151                                                       point GEOMETRY,
 152                                                       token_info JSONB)
 153   RETURNS BIGINT
 154   AS $$
 155 DECLARE
 156   parent BIGINT;
 157 BEGIN
 158   IF not token_has_addr_street(token_info) THEN
 159     RETURN NULL;
 160   END IF;
 161
 162 {% for partition in db.partitions %}
 163   IF in_partition = {{ partition }} THEN
 164     SELECT place_id FROM search_name_{{ partition }}
 165       INTO parent
 166       WHERE token_matches_street(token_info, name_vector)
 167             AND centroid && ST_Expand(point, 0.015)
 168             AND address_rank between 26 and 27
 169       ORDER BY ST_Distance(centroid, point) ASC limit 1;
 170     RETURN parent;
 171   END IF;
 172 {% endfor %}
 173
 174   RAISE EXCEPTION 'Unknown partition %', in_partition;
 175 END
 176 $$
 177 LANGUAGE plpgsql STABLE PARALLEL SAFE;
 178
 179 CREATE OR REPLACE FUNCTION getNearestNamedPlacePlaceId(in_partition INTEGER,
 180                                                        point GEOMETRY,
 181                                                        token_info JSONB)
 182   RETURNS BIGINT
 183   AS $$
 184 DECLARE
 185   parent BIGINT;
 186 BEGIN
 187   IF not token_has_addr_place(token_info) THEN
 188     RETURN NULL;
 189   END IF;
 190
 191 {% for partition in db.partitions %}
 192   IF in_partition = {{ partition }} THEN
 193     SELECT place_id
 194       INTO parent
 195       FROM search_name_{{ partition }}
 196       WHERE token_matches_place(token_info, name_vector)
 197             AND centroid && ST_Expand(point, 0.04)
 198             AND address_rank between 16 and 25
 199       ORDER BY ST_Distance(centroid, point) ASC limit 1;
 200     RETURN parent;
 201   END IF;
 202 {% endfor %}
 203
 204   RAISE EXCEPTION 'Unknown partition %', in_partition;
 205 END
 206 $$
 207 LANGUAGE plpgsql STABLE PARALLEL SAFE;
 208
 209 create or replace function insertSearchName(
 210   in_partition INTEGER, in_place_id BIGINT, in_name_vector INTEGER[],
 211   in_rank_search INTEGER, in_rank_address INTEGER, in_geometry GEOMETRY)
 212 RETURNS BOOLEAN AS $$
 213 DECLARE
 214 BEGIN
 215 {% for partition in db.partitions %}
 216   IF in_partition = {{ partition }} THEN
 217     DELETE FROM search_name_{{ partition }} values WHERE place_id = in_place_id;
 218     IF in_rank_address > 0 THEN
 219       INSERT INTO search_name_{{ partition }} (place_id, address_rank, name_vector, centroid)
 220         values (in_place_id, in_rank_address, in_name_vector, in_geometry);
 221     END IF;
 222     RETURN TRUE;
 223   END IF;
 224 {% endfor %}
 225
 226   RAISE EXCEPTION 'Unknown partition %', in_partition;
 227   RETURN FALSE;
 228 END
 229 $$
 230 LANGUAGE plpgsql;
 231
 232 create or replace function deleteSearchName(in_partition INTEGER, in_place_id BIGINT) RETURNS BOOLEAN AS $$
 233 DECLARE
 234 BEGIN
 235 {% for partition in db.partitions %}
 236   IF in_partition = {{ partition }} THEN
 237     DELETE from search_name_{{ partition }} WHERE place_id = in_place_id;
 238     RETURN TRUE;
 239   END IF;
 240 {% endfor %}
 241
 242   RAISE EXCEPTION 'Unknown partition %', in_partition;
 243
 244   RETURN FALSE;
 245 END
 246 $$
 247 LANGUAGE plpgsql;
 248
 249 create or replace function insertLocationRoad(
 250   in_partition INTEGER, in_place_id BIGINT, in_country_code VARCHAR(2), in_geometry GEOMETRY) RETURNS BOOLEAN AS $$
 251 DECLARE
 252 BEGIN
 253
 254 {% for partition in db.partitions %}
 255   IF in_partition = {{ partition }} THEN
 256     DELETE FROM location_road_{{ partition }} where place_id = in_place_id;
 257     INSERT INTO location_road_{{ partition }} (partition, place_id, country_code, geometry)
 258       values (in_partition, in_place_id, in_country_code, in_geometry);
 259     RETURN TRUE;
 260   END IF;
 261 {% endfor %}
 262
 263   RAISE EXCEPTION 'Unknown partition %', in_partition;
 264   RETURN FALSE;
 265 END
 266 $$
 267 LANGUAGE plpgsql;
 268
 269 create or replace function deleteRoad(in_partition INTEGER, in_place_id BIGINT) RETURNS BOOLEAN AS $$
 270 DECLARE
 271 BEGIN
 272
 273 {% for partition in db.partitions %}
 274   IF in_partition = {{ partition }} THEN
 275     DELETE FROM location_road_{{ partition }} where place_id = in_place_id;
 276     RETURN TRUE;
 277   END IF;
 278 {% endfor %}
 279
 280   RAISE EXCEPTION 'Unknown partition %', in_partition;
 281
 282   RETURN FALSE;
 283 END
 284 $$
 285 LANGUAGE plpgsql;
 286
 287 CREATE OR REPLACE FUNCTION getNearestRoadPlaceId(in_partition INTEGER, point GEOMETRY)
 288   RETURNS BIGINT
 289   AS $$
 290 DECLARE
 291   r RECORD;
 292   search_diameter FLOAT;
 293 BEGIN
 294
 295 {% for partition in db.partitions %}
 296   IF in_partition = {{ partition }} THEN
 297     search_diameter := 0.00005;
 298     WHILE search_diameter < 0.1 LOOP
 299       FOR r IN
 300         SELECT place_id FROM location_road_{{ partition }}
 301           WHERE ST_DWithin(geometry, point, search_diameter)
 302           ORDER BY ST_Distance(geometry, point) ASC limit 1
 303       LOOP
 304         RETURN r.place_id;
 305       END LOOP;
 306       search_diameter := search_diameter * 2;
 307     END LOOP;
 308     RETURN NULL;
 309   END IF;
 310 {% endfor %}
 311
 312   RAISE EXCEPTION 'Unknown partition %', in_partition;
 313 END
 314 $$
 315 LANGUAGE plpgsql STABLE PARALLEL SAFE;
 316
 317 CREATE OR REPLACE FUNCTION getNearestParallelRoadFeature(in_partition INTEGER,
 318                                                          line GEOMETRY)
 319   RETURNS BIGINT
 320   AS $$
 321 DECLARE
 322   r RECORD;
 323   search_diameter FLOAT;
 324   p1 GEOMETRY;
 325   p2 GEOMETRY;
 326   p3 GEOMETRY;
 327 BEGIN
 328
 329   IF ST_GeometryType(line) not in ('ST_LineString') THEN
 330     RETURN NULL;
 331   END IF;
 332
 333   p1 := ST_LineInterpolatePoint(line,0);
 334   p2 := ST_LineInterpolatePoint(line,0.5);
 335   p3 := ST_LineInterpolatePoint(line,1);
 336
 337 {% for partition in db.partitions %}
 338   IF in_partition = {{ partition }} THEN
 339     search_diameter := 0.0005;
 340     WHILE search_diameter < 0.01 LOOP
 341       FOR r IN
 342         SELECT place_id FROM location_road_{{ partition }}
 343           WHERE ST_DWithin(line, geometry, search_diameter)
 344           ORDER BY (ST_distance(geometry, p1)+
 345                     ST_distance(geometry, p2)+
 346                     ST_distance(geometry, p3)) ASC limit 1
 347       LOOP
 348         RETURN r.place_id;
 349       END LOOP;
 350       search_diameter := search_diameter * 2;
 351     END LOOP;
 352     RETURN NULL;
 353   END IF;
 354 {% endfor %}
 355
 356   RAISE EXCEPTION 'Unknown partition %', in_partition;
 357 END
 358 $$
 359 LANGUAGE plpgsql STABLE PARALLEL SAFE;