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