sql/functions/utils.sql

   1 -- Assorted helper functions for the triggers.
   2
   3 CREATE OR REPLACE FUNCTION geometry_sector(partition INTEGER, place geometry)
   4   RETURNS INTEGER
   5   AS $$
   6 DECLARE
   7   NEWgeometry geometry;
   8 BEGIN
   9 --  RAISE WARNING '%',place;
  10   NEWgeometry := ST_PointOnSurface(place);
  11   RETURN (partition*1000000) + (500-ST_X(NEWgeometry)::integer)*1000 + (500-ST_Y(NEWgeometry)::integer);
  12 END;
  13 $$
  14 LANGUAGE plpgsql IMMUTABLE;
  15
  16
  17 CREATE OR REPLACE FUNCTION array_merge(a INTEGER[], b INTEGER[])
  18   RETURNS INTEGER[]
  19   AS $$
  20 DECLARE
  21   i INTEGER;
  22   r INTEGER[];
  23 BEGIN
  24   IF array_upper(a, 1) IS NULL THEN
  25     RETURN b;
  26   END IF;
  27   IF array_upper(b, 1) IS NULL THEN
  28     RETURN a;
  29   END IF;
  30   r := a;
  31   FOR i IN 1..array_upper(b, 1) LOOP
  32     IF NOT (ARRAY[b[i]] <@ r) THEN
  33       r := r || b[i];
  34     END IF;
  35   END LOOP;
  36   RETURN r;
  37 END;
  38 $$
  39 LANGUAGE plpgsql IMMUTABLE;
  40
  41 -- Return the node members with a given label from a relation member list
  42 -- as a set.
  43 --
  44 -- \param members      Member list in osm2pgsql middle format.
  45 -- \param memberLabels Array of labels to accept.
  46 --
  47 -- \returns Set of OSM ids of nodes that are found.
  48 --
  49 CREATE OR REPLACE FUNCTION get_rel_node_members(members TEXT[],
  50                                                 memberLabels TEXT[])
  51   RETURNS SETOF BIGINT
  52   AS $$
  53 DECLARE
  54   i INTEGER;
  55 BEGIN
  56   FOR i IN 1..ARRAY_UPPER(members,1) BY 2 LOOP
  57     IF members[i+1] = ANY(memberLabels)
  58        AND upper(substring(members[i], 1, 1))::char(1) = 'N'
  59     THEN
  60       RETURN NEXT substring(members[i], 2)::bigint;
  61     END IF;
  62   END LOOP;
  63
  64   RETURN;
  65 END;
  66 $$
  67 LANGUAGE plpgsql IMMUTABLE;
  68
  69 -- Copy 'name' to or from the default language.
  70 --
  71 -- \param country_code     Country code of the object being named.
  72 -- \param[inout] name      List of names of the object.
  73 --
  74 -- If the country named by country_code has a single default language,
  75 -- then a `name` tag is copied to `name:<country_code>` if this tag does
  76 -- not yet exist and vice versa.
  77 CREATE OR REPLACE FUNCTION add_default_place_name(country_code VARCHAR(2),
  78                                                   INOUT name HSTORE)
  79   AS $$
  80 DECLARE
  81   default_language VARCHAR(10);
  82 BEGIN
  83   IF name is not null AND array_upper(akeys(name),1) > 1 THEN
  84     default_language := get_country_language_code(country_code);
  85     IF default_language IS NOT NULL THEN
  86       IF name ? 'name' AND NOT name ? ('name:'||default_language) THEN
  87         name := name || hstore(('name:'||default_language), (name -> 'name'));
  88       ELSEIF name ? ('name:'||default_language) AND NOT name ? 'name' THEN
  89         name := name || hstore('name', (name -> ('name:'||default_language)));
  90       END IF;
  91     END IF;
  92   END IF;
  93 END;
  94 $$
  95 LANGUAGE plpgsql IMMUTABLE;
  96
  97
  98 -- Find the nearest artificial postcode for the given geometry.
  99 -- TODO For areas there should not be more than two inside the geometry.
 100 CREATE OR REPLACE FUNCTION get_nearest_postcode(country VARCHAR(2), geom GEOMETRY)
 101   RETURNS TEXT
 102   AS $$
 103 DECLARE
 104   outcode TEXT;
 105   cnt INTEGER;
 106 BEGIN
 107     -- If the geometry is an area then only one postcode must be within
 108     -- that area, otherwise consider the area as not having a postcode.
 109     IF ST_GeometryType(geom) in ('ST_Polygon','ST_MultiPolygon') THEN
 110         SELECT min(postcode), count(*) FROM
 111               (SELECT postcode FROM location_postcode
 112                 WHERE ST_Contains(geom, location_postcode.geometry) LIMIT 2) sub
 113           INTO outcode, cnt;
 114
 115         IF cnt = 1 THEN
 116             RETURN outcode;
 117         ELSE
 118             RETURN null;
 119         END IF;
 120     END IF;
 121
 122     SELECT postcode FROM location_postcode
 123      WHERE ST_DWithin(geom, location_postcode.geometry, 0.05)
 124           AND location_postcode.country_code = country
 125      ORDER BY ST_Distance(geom, location_postcode.geometry) LIMIT 1
 126     INTO outcode;
 127
 128     RETURN outcode;
 129 END;
 130 $$
 131 LANGUAGE plpgsql STABLE;
 132
 133
 134 CREATE OR REPLACE FUNCTION get_country_code(place geometry)
 135   RETURNS TEXT
 136   AS $$
 137 DECLARE
 138   place_centre GEOMETRY;
 139   nearcountry RECORD;
 140 BEGIN
 141   place_centre := ST_PointOnSurface(place);
 142
 143 -- RAISE WARNING 'get_country_code, start: %', ST_AsText(place_centre);
 144
 145   -- Try for a OSM polygon
 146   FOR nearcountry IN
 147     SELECT country_code from location_area_country
 148     WHERE country_code is not null and st_covers(geometry, place_centre) limit 1
 149   LOOP
 150     RETURN nearcountry.country_code;
 151   END LOOP;
 152
 153 -- RAISE WARNING 'osm fallback: %', ST_AsText(place_centre);
 154
 155   -- Try for OSM fallback data
 156   -- The order is to deal with places like HongKong that are 'states' within another polygon
 157   FOR nearcountry IN
 158     SELECT country_code from country_osm_grid
 159     WHERE st_covers(geometry, place_centre) order by area asc limit 1
 160   LOOP
 161     RETURN nearcountry.country_code;
 162   END LOOP;
 163
 164 -- RAISE WARNING 'near osm fallback: %', ST_AsText(place_centre);
 165
 166   --
 167   FOR nearcountry IN
 168     SELECT country_code from country_osm_grid
 169     WHERE st_dwithin(geometry, place_centre, 0.5)
 170     ORDER BY st_distance(geometry, place_centre) asc, area asc limit 1
 171   LOOP
 172     RETURN nearcountry.country_code;
 173   END LOOP;
 174
 175   RETURN NULL;
 176 END;
 177 $$
 178 LANGUAGE plpgsql STABLE;
 179
 180
 181 CREATE OR REPLACE FUNCTION get_country_language_code(search_country_code VARCHAR(2))
 182   RETURNS TEXT
 183   AS $$
 184 DECLARE
 185   nearcountry RECORD;
 186 BEGIN
 187   FOR nearcountry IN
 188     SELECT distinct country_default_language_code from country_name
 189     WHERE country_code = search_country_code limit 1
 190   LOOP
 191     RETURN lower(nearcountry.country_default_language_code);
 192   END LOOP;
 193   RETURN NULL;
 194 END;
 195 $$
 196 LANGUAGE plpgsql STABLE;
 197
 198
 199 CREATE OR REPLACE FUNCTION get_partition(in_country_code VARCHAR(10))
 200   RETURNS INTEGER
 201   AS $$
 202 DECLARE
 203   nearcountry RECORD;
 204 BEGIN
 205   FOR nearcountry IN
 206     SELECT partition from country_name where country_code = in_country_code
 207   LOOP
 208     RETURN nearcountry.partition;
 209   END LOOP;
 210   RETURN 0;
 211 END;
 212 $$
 213 LANGUAGE plpgsql STABLE;
 214
 215
 216 -- Find the parent of an address with addr:street/addr:place tag.
 217 --
 218 -- \param street     Value of addr:street or NULL if tag is missing.
 219 -- \param place      Value of addr:place or NULL if tag is missing.
 220 -- \param partition  Partition where to search the parent.
 221 -- \param centroid   Location of the address.
 222 --
 223 -- \return Place ID of the parent if one was found, NULL otherwise.
 224 CREATE OR REPLACE FUNCTION find_parent_for_address(street TEXT, place TEXT,
 225                                                    partition SMALLINT,
 226                                                    centroid GEOMETRY)
 227   RETURNS BIGINT
 228   AS $$
 229 DECLARE
 230   parent_place_id BIGINT;
 231   word_ids INTEGER[];
 232 BEGIN
 233   IF street is not null THEN
 234     -- Check for addr:street attributes
 235     -- Note that addr:street links can only be indexed, once the street itself is indexed
 236     word_ids := word_ids_from_name(street);
 237     IF word_ids is not null THEN
 238       parent_place_id := getNearestNamedRoadPlaceId(partition, centroid, word_ids);
 239       IF parent_place_id is not null THEN
 240         --DEBUG: RAISE WARNING 'Get parent form addr:street: %', parent_place_id;
 241         RETURN parent_place_id;
 242       END IF;
 243     END IF;
 244   END IF;
 245
 246   -- Check for addr:place attributes.
 247   IF place is not null THEN
 248     word_ids := word_ids_from_name(place);
 249     IF word_ids is not null THEN
 250       parent_place_id := getNearestNamedPlacePlaceId(partition, centroid, word_ids);
 251       IF parent_place_id is not null THEN
 252         --DEBUG: RAISE WARNING 'Get parent form addr:place: %', parent_place_id;
 253         RETURN parent_place_id;
 254       END IF;
 255     END IF;
 256   END IF;
 257
 258   RETURN NULL;
 259 END;
 260 $$
 261 LANGUAGE plpgsql STABLE;
 262
 263 CREATE OR REPLACE FUNCTION delete_location(OLD_place_id BIGINT)
 264   RETURNS BOOLEAN
 265   AS $$
 266 DECLARE
 267 BEGIN
 268   DELETE FROM location_area where place_id = OLD_place_id;
 269 -- TODO:location_area
 270   RETURN true;
 271 END;
 272 $$
 273 LANGUAGE plpgsql;
 274
 275 CREATE OR REPLACE FUNCTION near_feature_rank_distance(rank_search INTEGER)
 276   RETURNS FLOAT
 277   AS $$
 278 BEGIN
 279   IF rank_search <= 16 THEN -- city
 280     RETURN 7500;
 281   ELSIF rank_search <= 18 THEN -- town
 282     RETURN 4000;
 283   ELSIF rank_search <= 19 THEN -- village
 284     RETURN 2000;
 285   ELSIF rank_search  <= 20 THEN -- hamlet
 286     RETURN 1000;
 287   END IF;
 288
 289   RETURN 500;
 290 END;
 291 $$
 292 LANGUAGE plpgsql IMMUTABLE;
 293
 294
 295 CREATE OR REPLACE FUNCTION add_location(place_id BIGINT, country_code varchar(2),
 296                                         partition INTEGER, keywords INTEGER[],
 297                                         rank_search INTEGER, rank_address INTEGER,
 298                                         in_postcode TEXT, geometry GEOMETRY)
 299   RETURNS BOOLEAN
 300   AS $$
 301 DECLARE
 302   locationid INTEGER;
 303   centroid GEOMETRY;
 304   radius FLOAT;
 305   secgeo GEOMETRY;
 306   postcode TEXT;
 307 BEGIN
 308   PERFORM deleteLocationArea(partition, place_id, rank_search);
 309
 310   -- add postcode only if it contains a single entry, i.e. ignore postcode lists
 311   postcode := NULL;
 312   IF in_postcode is not null AND in_postcode not similar to '%(,|;)%' THEN
 313       postcode := upper(trim (in_postcode));
 314   END IF;
 315
 316   IF ST_GeometryType(geometry) in ('ST_Polygon','ST_MultiPolygon') THEN
 317     centroid := ST_Centroid(geometry);
 318
 319     FOR secgeo IN select split_geometry(geometry) AS geom LOOP
 320       PERFORM insertLocationAreaLarge(partition, place_id, country_code, keywords, rank_search, rank_address, false, postcode, centroid, secgeo);
 321     END LOOP;
 322
 323   ELSEIF ST_GeometryType(geometry) = 'ST_Point' THEN
 324     radius := near_feature_rank_distance(rank_search);
 325     --DEBUG: RAISE WARNING 'adding % radius %', place_id, radius;
 326
 327     -- Create a bounding box with an extent computed from the radius (in meters).
 328     secgeo := ST_Envelope(ST_Collect(
 329                             ST_Project(geometry, radius, 0.785398)::geometry,
 330                             ST_Project(geometry, radius, 3.9269908)::geometry));
 331     PERFORM insertLocationAreaLarge(partition, place_id, country_code, keywords, rank_search, rank_address, true, postcode, geometry, secgeo);
 332
 333   END IF;
 334
 335   RETURN true;
 336 END;
 337 $$
 338 LANGUAGE plpgsql;
 339
 340
 341 CREATE OR REPLACE FUNCTION quad_split_geometry(geometry GEOMETRY, maxarea FLOAT,
 342                                                maxdepth INTEGER)
 343   RETURNS SETOF GEOMETRY
 344   AS $$
 345 DECLARE
 346   xmin FLOAT;
 347   ymin FLOAT;
 348   xmax FLOAT;
 349   ymax FLOAT;
 350   xmid FLOAT;
 351   ymid FLOAT;
 352   secgeo GEOMETRY;
 353   secbox GEOMETRY;
 354   seg INTEGER;
 355   geo RECORD;
 356   area FLOAT;
 357   remainingdepth INTEGER;
 358   added INTEGER;
 359 BEGIN
 360
 361 --  RAISE WARNING 'quad_split_geometry: maxarea=%, depth=%',maxarea,maxdepth;
 362
 363   IF (ST_GeometryType(geometry) not in ('ST_Polygon','ST_MultiPolygon') OR NOT ST_IsValid(geometry)) THEN
 364     RETURN NEXT geometry;
 365     RETURN;
 366   END IF;
 367
 368   remainingdepth := maxdepth - 1;
 369   area := ST_AREA(geometry);
 370   IF remainingdepth < 1 OR area < maxarea THEN
 371     RETURN NEXT geometry;
 372     RETURN;
 373   END IF;
 374
 375   xmin := st_xmin(geometry);
 376   xmax := st_xmax(geometry);
 377   ymin := st_ymin(geometry);
 378   ymax := st_ymax(geometry);
 379   secbox := ST_SetSRID(ST_MakeBox2D(ST_Point(ymin,xmin),ST_Point(ymax,xmax)),4326);
 380
 381   -- if the geometry completely covers the box don't bother to slice any more
 382   IF ST_AREA(secbox) = area THEN
 383     RETURN NEXT geometry;
 384     RETURN;
 385   END IF;
 386
 387   xmid := (xmin+xmax)/2;
 388   ymid := (ymin+ymax)/2;
 389
 390   added := 0;
 391   FOR seg IN 1..4 LOOP
 392
 393     IF seg = 1 THEN
 394       secbox := ST_SetSRID(ST_MakeBox2D(ST_Point(xmin,ymin),ST_Point(xmid,ymid)),4326);
 395     END IF;
 396     IF seg = 2 THEN
 397       secbox := ST_SetSRID(ST_MakeBox2D(ST_Point(xmin,ymid),ST_Point(xmid,ymax)),4326);
 398     END IF;
 399     IF seg = 3 THEN
 400       secbox := ST_SetSRID(ST_MakeBox2D(ST_Point(xmid,ymin),ST_Point(xmax,ymid)),4326);
 401     END IF;
 402     IF seg = 4 THEN
 403       secbox := ST_SetSRID(ST_MakeBox2D(ST_Point(xmid,ymid),ST_Point(xmax,ymax)),4326);
 404     END IF;
 405
 406     IF st_intersects(geometry, secbox) THEN
 407       secgeo := st_intersection(geometry, secbox);
 408       IF NOT ST_IsEmpty(secgeo) AND ST_GeometryType(secgeo) in ('ST_Polygon','ST_MultiPolygon') THEN
 409         FOR geo IN select quad_split_geometry(secgeo, maxarea, remainingdepth) as geom LOOP
 410           IF NOT ST_IsEmpty(geo.geom) AND ST_GeometryType(geo.geom) in ('ST_Polygon','ST_MultiPolygon') THEN
 411             added := added + 1;
 412             RETURN NEXT geo.geom;
 413           END IF;
 414         END LOOP;
 415       END IF;
 416     END IF;
 417   END LOOP;
 418
 419   RETURN;
 420 END;
 421 $$
 422 LANGUAGE plpgsql IMMUTABLE;
 423
 424
 425 CREATE OR REPLACE FUNCTION split_geometry(geometry GEOMETRY)
 426   RETURNS SETOF GEOMETRY
 427   AS $$
 428 DECLARE
 429   geo RECORD;
 430 BEGIN
 431   -- 10000000000 is ~~ 1x1 degree
 432   FOR geo IN select quad_split_geometry(geometry, 0.25, 20) as geom LOOP
 433     RETURN NEXT geo.geom;
 434   END LOOP;
 435   RETURN;
 436 END;
 437 $$
 438 LANGUAGE plpgsql IMMUTABLE;
 439
 440
 441 CREATE OR REPLACE FUNCTION place_force_delete(placeid BIGINT)
 442   RETURNS BOOLEAN
 443   AS $$
 444 DECLARE
 445     osmid BIGINT;
 446     osmtype character(1);
 447     pclass text;
 448     ptype text;
 449 BEGIN
 450   SELECT osm_type, osm_id, class, type FROM placex WHERE place_id = placeid INTO osmtype, osmid, pclass, ptype;
 451   DELETE FROM import_polygon_delete where osm_type = osmtype and osm_id = osmid and class = pclass and type = ptype;
 452   DELETE FROM import_polygon_error where osm_type = osmtype and osm_id = osmid and class = pclass and type = ptype;
 453   -- force delete from place/placex by making it a very small geometry
 454   UPDATE place set geometry = ST_SetSRID(ST_Point(0,0), 4326) where osm_type = osmtype and osm_id = osmid and class = pclass and type = ptype;
 455   DELETE FROM place where osm_type = osmtype and osm_id = osmid and class = pclass and type = ptype;
 456
 457   RETURN TRUE;
 458 END;
 459 $$
 460 LANGUAGE plpgsql;
 461
 462
 463 CREATE OR REPLACE FUNCTION place_force_update(placeid BIGINT)
 464   RETURNS BOOLEAN
 465   AS $$
 466 DECLARE
 467   placegeom GEOMETRY;
 468   geom GEOMETRY;
 469   diameter FLOAT;
 470   rank SMALLINT;
 471 BEGIN
 472   UPDATE placex SET indexed_status = 2 WHERE place_id = placeid;
 473   SELECT geometry, rank_search FROM placex WHERE place_id = placeid INTO placegeom, rank;
 474   IF placegeom IS NOT NULL AND ST_IsValid(placegeom) THEN
 475     IF ST_GeometryType(placegeom) in ('ST_Polygon','ST_MultiPolygon') THEN
 476       FOR geom IN select split_geometry(placegeom) FROM placex WHERE place_id = placeid LOOP
 477         update placex set indexed_status = 2 where (st_covers(geom, placex.geometry) OR ST_Intersects(geom, placex.geometry))
 478         AND rank_search > rank and indexed_status = 0 and ST_geometrytype(placex.geometry) = 'ST_Point' and (rank_search < 28 or name is not null or (rank >= 16 and address ? 'place'));
 479         update placex set indexed_status = 2 where (st_covers(geom, placex.geometry) OR ST_Intersects(geom, placex.geometry))
 480         AND rank_search > rank and indexed_status = 0 and ST_geometrytype(placex.geometry) != 'ST_Point' and (rank_search < 28 or name is not null or (rank >= 16 and address ? 'place'));
 481       END LOOP;
 482     ELSE
 483         diameter := update_place_diameter(rank);
 484         IF diameter > 0 THEN
 485           IF rank >= 26 THEN
 486             -- roads may cause reparenting for >27 rank places
 487             update placex set indexed_status = 2 where indexed_status = 0 and rank_search > rank and ST_DWithin(placex.geometry, placegeom, diameter);
 488           ELSEIF rank >= 16 THEN
 489             -- up to rank 16, street-less addresses may need reparenting
 490             update placex set indexed_status = 2 where indexed_status = 0 and rank_search > rank and ST_DWithin(placex.geometry, placegeom, diameter) and (rank_search < 28 or name is not null or address ? 'place');
 491           ELSE
 492             -- for all other places the search terms may change as well
 493             update placex set indexed_status = 2 where indexed_status = 0 and rank_search > rank and ST_DWithin(placex.geometry, placegeom, diameter) and (rank_search < 28 or name is not null);
 494           END IF;
 495         END IF;
 496     END IF;
 497     RETURN TRUE;
 498   END IF;
 499
 500   RETURN FALSE;
 501 END;
 502 $$
 503 LANGUAGE plpgsql;