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