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) 2026 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     IF in_rank_address > 0 THEN
 218       INSERT INTO search_name_{{ partition }} (place_id, address_rank, name_vector, centroid)
 219         values (in_place_id, in_rank_address, in_name_vector, in_geometry);
 220     END IF;
 221     RETURN TRUE;
 222   END IF;
 223 {% endfor %}
 224
 225   RAISE EXCEPTION 'Unknown partition %', in_partition;
 226   RETURN FALSE;
 227 END
 228 $$
 229 LANGUAGE plpgsql;
 230
 231 create or replace function deleteSearchName(in_partition INTEGER, in_place_id BIGINT) RETURNS BOOLEAN AS $$
 232 DECLARE
 233 BEGIN
 234 {% for partition in db.partitions %}
 235   IF in_partition = {{ partition }} THEN
 236     DELETE from search_name_{{ partition }} WHERE place_id = in_place_id;
 237     RETURN TRUE;
 238   END IF;
 239 {% endfor %}
 240
 241   RAISE EXCEPTION 'Unknown partition %', in_partition;
 242
 243   RETURN FALSE;
 244 END
 245 $$
 246 LANGUAGE plpgsql;
 247
 248 create or replace function insertLocationRoad(
 249   in_partition INTEGER, in_place_id BIGINT, in_country_code VARCHAR(2), in_geometry GEOMETRY) RETURNS BOOLEAN AS $$
 250 DECLARE
 251 BEGIN
 252
 253 {% for partition in db.partitions %}
 254   IF in_partition = {{ partition }} THEN
 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;