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