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 and not in_estimate THEN
 127     INSERT INTO location_area_country (place_id, country_code, geometry)
 128       (SELECT in_place_id, in_country_code, geom
 129        FROM split_geometry(in_geometry) as geom);
 130     RETURN TRUE;
 131   END IF;
 132
 133 {% for partition in db.partitions %}
 134   IF in_partition = {{ partition }} THEN
 135     INSERT INTO location_area_large_{{ partition }} (partition, place_id, country_code, keywords, rank_search, rank_address, isguess, postcode, centroid, geometry)
 136       (SELECT in_partition, in_place_id, in_country_code, in_keywords, in_rank_search, in_rank_address, in_estimate, postcode, in_centroid, geom
 137        FROM split_geometry(in_geometry) as geom);
 138     RETURN TRUE;
 139   END IF;
 140 {% endfor %}
 141
 142   RAISE EXCEPTION 'Unknown partition %', in_partition;
 143   RETURN FALSE;
 144 END
 145 $$
 146 LANGUAGE plpgsql;
 147
 148 CREATE OR REPLACE FUNCTION getNearestNamedRoadPlaceId(in_partition INTEGER,
 149                                                       point GEOMETRY,
 150                                                       token_info JSONB)
 151   RETURNS BIGINT
 152   AS $$
 153 DECLARE
 154   parent BIGINT;
 155 BEGIN
 156   IF not token_has_addr_street(token_info) THEN
 157     RETURN NULL;
 158   END IF;
 159
 160 {% for partition in db.partitions %}
 161   IF in_partition = {{ partition }} THEN
 162     SELECT place_id FROM search_name_{{ partition }}
 163       INTO parent
 164       WHERE token_matches_street(token_info, name_vector)
 165             AND centroid && ST_Expand(point, 0.015)
 166             AND address_rank between 26 and 27
 167       ORDER BY ST_Distance(centroid, point) ASC limit 1;
 168     RETURN parent;
 169   END IF;
 170 {% endfor %}
 171
 172   RAISE EXCEPTION 'Unknown partition %', in_partition;
 173 END
 174 $$
 175 LANGUAGE plpgsql STABLE PARALLEL SAFE;
 176
 177 CREATE OR REPLACE FUNCTION getNearestNamedPlacePlaceId(in_partition INTEGER,
 178                                                        point GEOMETRY,
 179                                                        token_info JSONB)
 180   RETURNS BIGINT
 181   AS $$
 182 DECLARE
 183   parent BIGINT;
 184 BEGIN
 185   IF not token_has_addr_place(token_info) THEN
 186     RETURN NULL;
 187   END IF;
 188
 189 {% for partition in db.partitions %}
 190   IF in_partition = {{ partition }} THEN
 191     SELECT place_id
 192       INTO parent
 193       FROM search_name_{{ partition }}
 194       WHERE token_matches_place(token_info, name_vector)
 195             AND centroid && ST_Expand(point, 0.04)
 196             AND address_rank between 16 and 25
 197       ORDER BY ST_Distance(centroid, point) ASC limit 1;
 198     RETURN parent;
 199   END IF;
 200 {% endfor %}
 201
 202   RAISE EXCEPTION 'Unknown partition %', in_partition;
 203 END
 204 $$
 205 LANGUAGE plpgsql STABLE PARALLEL SAFE;
 206
 207 create or replace function insertSearchName(
 208   in_partition INTEGER, in_place_id BIGINT, in_name_vector INTEGER[],
 209   in_rank_search INTEGER, in_rank_address INTEGER, in_geometry GEOMETRY)
 210 RETURNS BOOLEAN AS $$
 211 DECLARE
 212 BEGIN
 213 {% for partition in db.partitions %}
 214   IF in_partition = {{ partition }} THEN
 215     DELETE FROM search_name_{{ partition }} values WHERE place_id = in_place_id;
 216     IF in_rank_address > 0 THEN
 217       INSERT INTO search_name_{{ partition }} (place_id, address_rank, name_vector, centroid)
 218         values (in_place_id, in_rank_address, in_name_vector, in_geometry);
 219     END IF;
 220     RETURN TRUE;
 221   END IF;
 222 {% endfor %}
 223
 224   RAISE EXCEPTION 'Unknown partition %', in_partition;
 225   RETURN FALSE;
 226 END
 227 $$
 228 LANGUAGE plpgsql;
 229
 230 create or replace function deleteSearchName(in_partition INTEGER, in_place_id BIGINT) RETURNS BOOLEAN AS $$
 231 DECLARE
 232 BEGIN
 233 {% for partition in db.partitions %}
 234   IF in_partition = {{ partition }} THEN
 235     DELETE from search_name_{{ partition }} WHERE place_id = in_place_id;
 236     RETURN TRUE;
 237   END IF;
 238 {% endfor %}
 239
 240   RAISE EXCEPTION 'Unknown partition %', in_partition;
 241
 242   RETURN FALSE;
 243 END
 244 $$
 245 LANGUAGE plpgsql;
 246
 247 create or replace function insertLocationRoad(
 248   in_partition INTEGER, in_place_id BIGINT, in_country_code VARCHAR(2), in_geometry GEOMETRY) RETURNS BOOLEAN AS $$
 249 DECLARE
 250 BEGIN
 251
 252 {% for partition in db.partitions %}
 253   IF in_partition = {{ partition }} THEN
 254     DELETE FROM location_road_{{ partition }} where place_id = in_place_id;
 255     INSERT INTO location_road_{{ partition }} (partition, place_id, country_code, geometry)
 256       values (in_partition, in_place_id, in_country_code, in_geometry);
 257     RETURN TRUE;
 258   END IF;
 259 {% endfor %}
 260
 261   RAISE EXCEPTION 'Unknown partition %', in_partition;
 262   RETURN FALSE;
 263 END
 264 $$
 265 LANGUAGE plpgsql;
 266
 267 create or replace function deleteRoad(in_partition INTEGER, in_place_id BIGINT) RETURNS BOOLEAN AS $$
 268 DECLARE
 269 BEGIN
 270
 271 {% for partition in db.partitions %}
 272   IF in_partition = {{ partition }} THEN
 273     DELETE FROM location_road_{{ partition }} where place_id = in_place_id;
 274     RETURN TRUE;
 275   END IF;
 276 {% endfor %}
 277
 278   RAISE EXCEPTION 'Unknown partition %', in_partition;
 279
 280   RETURN FALSE;
 281 END
 282 $$
 283 LANGUAGE plpgsql;
 284
 285 CREATE OR REPLACE FUNCTION getNearestRoadPlaceId(in_partition INTEGER, point GEOMETRY)
 286   RETURNS BIGINT
 287   AS $$
 288 DECLARE
 289   r RECORD;
 290   search_diameter FLOAT;
 291 BEGIN
 292
 293 {% for partition in db.partitions %}
 294   IF in_partition = {{ partition }} THEN
 295     search_diameter := 0.00005;
 296     WHILE search_diameter < 0.1 LOOP
 297       FOR r IN
 298         SELECT place_id FROM location_road_{{ partition }}
 299           WHERE ST_DWithin(geometry, point, search_diameter)
 300           ORDER BY ST_Distance(geometry, point) ASC limit 1
 301       LOOP
 302         RETURN r.place_id;
 303       END LOOP;
 304       search_diameter := search_diameter * 2;
 305     END LOOP;
 306     RETURN NULL;
 307   END IF;
 308 {% endfor %}
 309
 310   RAISE EXCEPTION 'Unknown partition %', in_partition;
 311 END
 312 $$
 313 LANGUAGE plpgsql STABLE PARALLEL SAFE;
 314
 315 CREATE OR REPLACE FUNCTION getNearestParallelRoadFeature(in_partition INTEGER,
 316                                                          line GEOMETRY)
 317   RETURNS BIGINT
 318   AS $$
 319 DECLARE
 320   r RECORD;
 321   search_diameter FLOAT;
 322   p1 GEOMETRY;
 323   p2 GEOMETRY;
 324   p3 GEOMETRY;
 325 BEGIN
 326
 327   IF ST_GeometryType(line) not in ('ST_LineString') THEN
 328     RETURN NULL;
 329   END IF;
 330
 331   p1 := ST_LineInterpolatePoint(line,0);
 332   p2 := ST_LineInterpolatePoint(line,0.5);
 333   p3 := ST_LineInterpolatePoint(line,1);
 334
 335 {% for partition in db.partitions %}
 336   IF in_partition = {{ partition }} THEN
 337     search_diameter := 0.0005;
 338     WHILE search_diameter < 0.01 LOOP
 339       FOR r IN
 340         SELECT place_id FROM location_road_{{ partition }}
 341           WHERE ST_DWithin(line, geometry, search_diameter)
 342           ORDER BY (ST_distance(geometry, p1)+
 343                     ST_distance(geometry, p2)+
 344                     ST_distance(geometry, p3)) ASC limit 1
 345       LOOP
 346         RETURN r.place_id;
 347       END LOOP;
 348       search_diameter := search_diameter * 2;
 349     END LOOP;
 350     RETURN NULL;
 351   END IF;
 352 {% endfor %}
 353
 354   RAISE EXCEPTION 'Unknown partition %', in_partition;
 355 END
 356 $$
 357 LANGUAGE plpgsql STABLE PARALLEL SAFE;