lib-sql/functions/placex_triggers.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 -- Trigger functions for the placex table.
   9
  10 -- Information returned by update preparation.
  11 DROP TYPE IF EXISTS prepare_update_info CASCADE;
  12 CREATE TYPE prepare_update_info AS (
  13   name HSTORE,
  14   address HSTORE,
  15   rank_address SMALLINT,
  16   country_code TEXT,
  17   class TEXT,
  18   type TEXT,
  19   linked_place_id BIGINT
  20 );
  21
  22 -- Retrieve the data needed by the indexer for updating the place.
  23 CREATE OR REPLACE FUNCTION placex_indexing_prepare(p placex)
  24   RETURNS prepare_update_info
  25   AS $$
  26 DECLARE
  27   location RECORD;
  28   result prepare_update_info;
  29 BEGIN
  30   -- For POI nodes, check if the address should be derived from a surrounding
  31   -- building.
  32   IF p.rank_search < 30 OR p.osm_type != 'N' THEN
  33     result.address := p.address;
  34   ELSEIF p.address is null THEN
  35     -- The additional && condition works around the misguided query
  36     -- planner of postgis 3.0.
  37     SELECT placex.address || hstore('_inherited', '') INTO result.address
  38       FROM placex
  39      WHERE ST_Covers(geometry, p.centroid)
  40            and geometry && p.centroid
  41            and placex.address is not null
  42            and (placex.address ? 'housenumber' or placex.address ? 'street' or placex.address ? 'place')
  43            and rank_search = 30 AND ST_GeometryType(geometry) in ('ST_Polygon','ST_MultiPolygon')
  44      LIMIT 1;
  45   ELSE
  46     result.address := p.address;
  47     -- See if we can inherit addtional address tags from an interpolation.
  48     -- These will become permanent.
  49     FOR location IN
  50       SELECT (address - 'interpolation'::text - 'housenumber'::text) as address
  51         FROM place, planet_osm_ways w
  52         WHERE place.osm_type = 'W' and place.address ? 'interpolation'
  53               and place.geometry && p.geometry
  54               and place.osm_id = w.id
  55               and p.osm_id = any(w.nodes)
  56     LOOP
  57       result.address := location.address || result.address;
  58     END LOOP;
  59   END IF;
  60
  61   result.address := result.address - '_unlisted_place'::TEXT;
  62   result.name := p.name;
  63   result.class := p.class;
  64   result.type := p.type;
  65   result.country_code := p.country_code;
  66   result.rank_address := p.rank_address;
  67
  68   -- Names of linked places need to be merged in, so search for a linkable
  69   -- place already here.
  70   SELECT * INTO location FROM find_linked_place(p);
  71
  72   IF location.place_id is not NULL THEN
  73     result.linked_place_id := location.place_id;
  74
  75     IF NOT location.name IS NULL THEN
  76       result.name := location.name || result.name;
  77     END IF;
  78   END IF;
  79
  80   RETURN result;
  81 END;
  82 $$
  83 LANGUAGE plpgsql STABLE;
  84
  85
  86 CREATE OR REPLACE FUNCTION find_associated_street(poi_osm_type CHAR(1),
  87                                                   poi_osm_id BIGINT)
  88   RETURNS BIGINT
  89   AS $$
  90 DECLARE
  91   location RECORD;
  92   parent RECORD;
  93 BEGIN
  94   FOR location IN
  95     SELECT members FROM planet_osm_rels
  96     WHERE parts @> ARRAY[poi_osm_id]
  97           and members @> ARRAY[lower(poi_osm_type) || poi_osm_id]
  98           and tags @> ARRAY['associatedStreet']
  99   LOOP
 100     FOR i IN 1..array_upper(location.members, 1) BY 2 LOOP
 101       IF location.members[i+1] = 'street' THEN
 102         FOR parent IN
 103           SELECT place_id from placex
 104            WHERE osm_type = 'W' and osm_id = substring(location.members[i],2)::bigint
 105                  and name is not null
 106                  and rank_search between 26 and 27
 107         LOOP
 108           RETURN parent.place_id;
 109         END LOOP;
 110       END IF;
 111     END LOOP;
 112   END LOOP;
 113
 114   RETURN NULL;
 115 END;
 116 $$
 117 LANGUAGE plpgsql STABLE;
 118
 119
 120 -- Find the parent road of a POI.
 121 --
 122 -- \returns Place ID of parent object or NULL if none
 123 --
 124 -- Copy data from linked items (POIs on ways, addr:street links, relations).
 125 --
 126 CREATE OR REPLACE FUNCTION find_parent_for_poi(poi_osm_type CHAR(1),
 127                                                poi_osm_id BIGINT,
 128                                                poi_partition SMALLINT,
 129                                                bbox GEOMETRY,
 130                                                token_info JSONB,
 131                                                is_place_addr BOOLEAN)
 132   RETURNS BIGINT
 133   AS $$
 134 DECLARE
 135   parent_place_id BIGINT DEFAULT NULL;
 136   location RECORD;
 137 BEGIN
 138   {% if debug %}RAISE WARNING 'finding street for % %', poi_osm_type, poi_osm_id;{% endif %}
 139
 140   -- Is this object part of an associatedStreet relation?
 141   parent_place_id := find_associated_street(poi_osm_type, poi_osm_id);
 142
 143   IF parent_place_id is null THEN
 144     parent_place_id := find_parent_for_address(token_info, poi_partition, bbox);
 145   END IF;
 146
 147   IF parent_place_id is null and poi_osm_type = 'N' THEN
 148     FOR location IN
 149       SELECT p.place_id, p.osm_id, p.rank_search, p.address,
 150              coalesce(p.centroid, ST_Centroid(p.geometry)) as centroid
 151         FROM placex p, planet_osm_ways w
 152        WHERE p.osm_type = 'W' and p.rank_search >= 26
 153              and p.geometry && bbox
 154              and w.id = p.osm_id and poi_osm_id = any(w.nodes)
 155     LOOP
 156       {% if debug %}RAISE WARNING 'Node is part of way % ', location.osm_id;{% endif %}
 157
 158       -- Way IS a road then we are on it - that must be our road
 159       IF location.rank_search < 28 THEN
 160         {% if debug %}RAISE WARNING 'node in way that is a street %',location;{% endif %}
 161         RETURN location.place_id;
 162       END IF;
 163
 164       parent_place_id := find_associated_street('W', location.osm_id);
 165     END LOOP;
 166   END IF;
 167
 168   IF parent_place_id is NULL THEN
 169     IF is_place_addr THEN
 170       -- The address is attached to a place we don't know.
 171       -- Instead simply use the containing area with the largest rank.
 172       FOR location IN
 173         SELECT place_id FROM placex
 174          WHERE bbox && geometry AND _ST_Covers(geometry, ST_Centroid(bbox))
 175                AND rank_address between 5 and 25
 176          ORDER BY rank_address desc
 177       LOOP
 178         RETURN location.place_id;
 179       END LOOP;
 180     ELSEIF ST_Area(bbox) < 0.005 THEN
 181       -- for smaller features get the nearest road
 182       SELECT getNearestRoadPlaceId(poi_partition, bbox) INTO parent_place_id;
 183       {% if debug %}RAISE WARNING 'Checked for nearest way (%)', parent_place_id;{% endif %}
 184     ELSE
 185       -- for larger features simply find the area with the largest rank that
 186       -- contains the bbox, only use addressable features
 187       FOR location IN
 188         SELECT place_id FROM placex
 189          WHERE bbox && geometry AND _ST_Covers(geometry, ST_Centroid(bbox))
 190                AND rank_address between 5 and 25
 191         ORDER BY rank_address desc
 192       LOOP
 193         RETURN location.place_id;
 194       END LOOP;
 195     END IF;
 196   END IF;
 197
 198   RETURN parent_place_id;
 199 END;
 200 $$
 201 LANGUAGE plpgsql STABLE;
 202
 203 -- Try to find a linked place for the given object.
 204 CREATE OR REPLACE FUNCTION find_linked_place(bnd placex)
 205   RETURNS placex
 206   AS $$
 207 DECLARE
 208   relation_members TEXT[];
 209   rel_member RECORD;
 210   linked_placex placex%ROWTYPE;
 211   bnd_name TEXT;
 212 BEGIN
 213   IF bnd.rank_search >= 26 or bnd.rank_address = 0
 214      or ST_GeometryType(bnd.geometry) NOT IN ('ST_Polygon','ST_MultiPolygon')
 215      or bnd.type IN ('postcode', 'postal_code')
 216   THEN
 217     RETURN NULL;
 218   END IF;
 219
 220   IF bnd.osm_type = 'R' THEN
 221     -- see if we have any special relation members
 222     SELECT members FROM planet_osm_rels WHERE id = bnd.osm_id INTO relation_members;
 223     {% if debug %}RAISE WARNING 'Got relation members';{% endif %}
 224
 225     -- Search for relation members with role 'lable'.
 226     IF relation_members IS NOT NULL THEN
 227       FOR rel_member IN
 228         SELECT get_rel_node_members(relation_members, ARRAY['label']) as member
 229       LOOP
 230         {% if debug %}RAISE WARNING 'Found label member %', rel_member.member;{% endif %}
 231
 232         FOR linked_placex IN
 233           SELECT * from placex
 234           WHERE osm_type = 'N' and osm_id = rel_member.member
 235             and class = 'place'
 236         LOOP
 237           {% if debug %}RAISE WARNING 'Linked label member';{% endif %}
 238           RETURN linked_placex;
 239         END LOOP;
 240
 241       END LOOP;
 242     END IF;
 243   END IF;
 244
 245   IF bnd.name ? 'name' THEN
 246     bnd_name := lower(bnd.name->'name');
 247     IF bnd_name = '' THEN
 248       bnd_name := NULL;
 249     END IF;
 250   END IF;
 251
 252   -- If extratags has a place tag, look for linked nodes by their place type.
 253   -- Area and node still have to have the same name.
 254   IF bnd.extratags ? 'place' and bnd_name is not null THEN
 255     FOR linked_placex IN
 256       SELECT * FROM placex
 257       WHERE (position(lower(name->'name') in bnd_name) > 0
 258              OR position(bnd_name in lower(name->'name')) > 0)
 259         AND placex.class = 'place' AND placex.type = bnd.extratags->'place'
 260         AND placex.osm_type = 'N'
 261         AND placex.linked_place_id is null
 262         AND placex.rank_search < 26 -- needed to select the right index
 263         AND placex.type != 'postcode'
 264         AND ST_Covers(bnd.geometry, placex.geometry)
 265     LOOP
 266       {% if debug %}RAISE WARNING 'Found type-matching place node %', linked_placex.osm_id;{% endif %}
 267       RETURN linked_placex;
 268     END LOOP;
 269   END IF;
 270
 271   IF bnd.extratags ? 'wikidata' THEN
 272     FOR linked_placex IN
 273       SELECT * FROM placex
 274       WHERE placex.class = 'place' AND placex.osm_type = 'N'
 275         AND placex.extratags ? 'wikidata' -- needed to select right index
 276         AND placex.extratags->'wikidata' = bnd.extratags->'wikidata'
 277         AND placex.linked_place_id is null
 278         AND placex.rank_search < 26
 279         AND _st_covers(bnd.geometry, placex.geometry)
 280       ORDER BY lower(name->'name') = bnd_name desc
 281     LOOP
 282       {% if debug %}RAISE WARNING 'Found wikidata-matching place node %', linked_placex.osm_id;{% endif %}
 283       RETURN linked_placex;
 284     END LOOP;
 285   END IF;
 286
 287   -- Name searches can be done for ways as well as relations
 288   IF bnd_name is not null THEN
 289     {% if debug %}RAISE WARNING 'Looking for nodes with matching names';{% endif %}
 290     FOR linked_placex IN
 291       SELECT placex.* from placex
 292       WHERE lower(name->'name') = bnd_name
 293         AND ((bnd.rank_address > 0
 294               and bnd.rank_address = (compute_place_rank(placex.country_code,
 295                                                          'N', placex.class,
 296                                                          placex.type, 15::SMALLINT,
 297                                                          false, placex.postcode)).address_rank)
 298              OR (bnd.rank_address = 0 and placex.rank_search = bnd.rank_search))
 299         AND placex.osm_type = 'N'
 300         AND placex.class = 'place'
 301         AND placex.linked_place_id is null
 302         AND placex.rank_search < 26 -- needed to select the right index
 303         AND placex.type != 'postcode'
 304         AND ST_Covers(bnd.geometry, placex.geometry)
 305     LOOP
 306       {% if debug %}RAISE WARNING 'Found matching place node %', linked_placex.osm_id;{% endif %}
 307       RETURN linked_placex;
 308     END LOOP;
 309   END IF;
 310
 311   RETURN NULL;
 312 END;
 313 $$
 314 LANGUAGE plpgsql STABLE;
 315
 316
 317 CREATE OR REPLACE FUNCTION create_poi_search_terms(obj_place_id BIGINT,
 318                                                    in_partition SMALLINT,
 319                                                    parent_place_id BIGINT,
 320                                                    is_place_addr BOOLEAN,
 321                                                    country TEXT,
 322                                                    token_info JSONB,
 323                                                    geometry GEOMETRY,
 324                                                    OUT name_vector INTEGER[],
 325                                                    OUT nameaddress_vector INTEGER[])
 326   AS $$
 327 DECLARE
 328   parent_name_vector INTEGER[];
 329   parent_address_vector INTEGER[];
 330   addr_place_ids INTEGER[];
 331   hnr_vector INTEGER[];
 332
 333   addr_item RECORD;
 334   addr_place RECORD;
 335   parent_address_place_ids BIGINT[];
 336 BEGIN
 337   nameaddress_vector := '{}'::INTEGER[];
 338
 339   SELECT s.name_vector, s.nameaddress_vector
 340     INTO parent_name_vector, parent_address_vector
 341     FROM search_name s
 342     WHERE s.place_id = parent_place_id;
 343
 344   FOR addr_item IN
 345     SELECT (get_addr_tag_rank(key, country)).*, key,
 346            token_get_address_search_tokens(token_info, key) as search_tokens
 347       FROM token_get_address_keys(token_info) as key
 348       WHERE not token_get_address_search_tokens(token_info, key) <@ parent_address_vector
 349   LOOP
 350     addr_place := get_address_place(in_partition, geometry,
 351                                     addr_item.from_rank, addr_item.to_rank,
 352                                     addr_item.extent, token_info, addr_item.key);
 353
 354     IF addr_place is null THEN
 355       -- No place found in OSM that matches. Make it at least searchable.
 356       nameaddress_vector := array_merge(nameaddress_vector, addr_item.search_tokens);
 357     ELSE
 358       IF parent_address_place_ids is null THEN
 359         SELECT array_agg(parent_place_id) INTO parent_address_place_ids
 360           FROM place_addressline
 361           WHERE place_id = parent_place_id;
 362       END IF;
 363
 364       -- If the parent already lists the place in place_address line, then we
 365       -- are done. Otherwise, add its own place_address line.
 366       IF not parent_address_place_ids @> ARRAY[addr_place.place_id] THEN
 367         nameaddress_vector := array_merge(nameaddress_vector, addr_place.keywords);
 368
 369         INSERT INTO place_addressline (place_id, address_place_id, fromarea,
 370                                        isaddress, distance, cached_rank_address)
 371           VALUES (obj_place_id, addr_place.place_id, not addr_place.isguess,
 372                     true, addr_place.distance, addr_place.rank_address);
 373       END IF;
 374     END IF;
 375   END LOOP;
 376
 377   name_vector := token_get_name_search_tokens(token_info);
 378
 379   -- Check if the parent covers all address terms.
 380   -- If not, create a search name entry with the house number as the name.
 381   -- This is unusual for the search_name table but prevents that the place
 382   -- is returned when we only search for the street/place.
 383
 384   hnr_vector := token_get_housenumber_search_tokens(token_info);
 385
 386   IF hnr_vector is not null and not nameaddress_vector <@ parent_address_vector THEN
 387     name_vector := array_merge(name_vector, hnr_vector);
 388   END IF;
 389
 390   IF is_place_addr THEN
 391     addr_place_ids := token_addr_place_search_tokens(token_info);
 392     IF not addr_place_ids <@ parent_name_vector THEN
 393       -- make sure addr:place terms are always searchable
 394       nameaddress_vector := array_merge(nameaddress_vector, addr_place_ids);
 395       -- If there is a housenumber, also add the place name as a name,
 396       -- so we can search it by the usual housenumber+place algorithms.
 397       IF hnr_vector is not null THEN
 398         name_vector := array_merge(name_vector, addr_place_ids);
 399       END IF;
 400     END IF;
 401   END IF;
 402
 403   -- Cheating here by not recomputing all terms but simply using the ones
 404   -- from the parent object.
 405   nameaddress_vector := array_merge(nameaddress_vector, parent_name_vector);
 406   nameaddress_vector := array_merge(nameaddress_vector, parent_address_vector);
 407
 408 END;
 409 $$
 410 LANGUAGE plpgsql;
 411
 412
 413 -- Insert address of a place into the place_addressline table.
 414 --
 415 -- \param obj_place_id  Place_id of the place to compute the address for.
 416 -- \param partition     Partition number where the place is in.
 417 -- \param maxrank       Rank of the place. All address features must have
 418 --                      a search rank lower than the given rank.
 419 -- \param address       Address terms for the place.
 420 -- \param geometry      Geometry to which the address objects should be close.
 421 --
 422 -- \retval parent_place_id  Place_id of the address object that is the direct
 423 --                          ancestor.
 424 -- \retval postcode         Postcode computed from the address. This is the
 425 --                          addr:postcode of one of the address objects. If
 426 --                          more than one of has a postcode, the highest ranking
 427 --                          one is used. May be NULL.
 428 -- \retval nameaddress_vector  Search terms for the address. This is the sum
 429 --                             of name terms of all address objects.
 430 CREATE OR REPLACE FUNCTION insert_addresslines(obj_place_id BIGINT,
 431                                                partition SMALLINT,
 432                                                maxrank SMALLINT,
 433                                                token_info JSONB,
 434                                                geometry GEOMETRY,
 435                                                country TEXT,
 436                                                OUT parent_place_id BIGINT,
 437                                                OUT postcode TEXT,
 438                                                OUT nameaddress_vector INT[])
 439   AS $$
 440 DECLARE
 441   address_havelevel BOOLEAN[];
 442
 443   location_isaddress BOOLEAN;
 444   current_boundary GEOMETRY := NULL;
 445   current_node_area GEOMETRY := NULL;
 446
 447   parent_place_rank INT := 0;
 448   addr_place_ids BIGINT[] := '{}'::int[];
 449   new_address_vector INT[];
 450
 451   location RECORD;
 452 BEGIN
 453   parent_place_id := 0;
 454   nameaddress_vector := '{}'::int[];
 455
 456   address_havelevel := array_fill(false, ARRAY[maxrank]);
 457
 458   FOR location IN
 459     SELECT (get_address_place(partition, geometry, from_rank, to_rank,
 460                               extent, token_info, key)).*, key
 461       FROM (SELECT (get_addr_tag_rank(key, country)).*, key
 462               FROM token_get_address_keys(token_info) as key) x
 463       ORDER BY rank_address, distance, isguess desc
 464   LOOP
 465     IF location.place_id is null THEN
 466       {% if not db.reverse_only %}
 467       nameaddress_vector := array_merge(nameaddress_vector,
 468                                         token_get_address_search_tokens(token_info,
 469                                                                         location.key));
 470       {% endif %}
 471     ELSE
 472       {% if not db.reverse_only %}
 473       nameaddress_vector := array_merge(nameaddress_vector, location.keywords::INTEGER[]);
 474       {% endif %}
 475
 476       location_isaddress := not address_havelevel[location.rank_address];
 477       IF not address_havelevel[location.rank_address] THEN
 478         address_havelevel[location.rank_address] := true;
 479         IF parent_place_rank < location.rank_address THEN
 480           parent_place_id := location.place_id;
 481           parent_place_rank := location.rank_address;
 482         END IF;
 483       END IF;
 484
 485       INSERT INTO place_addressline (place_id, address_place_id, fromarea,
 486                                      isaddress, distance, cached_rank_address)
 487         VALUES (obj_place_id, location.place_id, not location.isguess,
 488                 true, location.distance, location.rank_address);
 489
 490       addr_place_ids := addr_place_ids || location.place_id;
 491     END IF;
 492   END LOOP;
 493
 494   FOR location IN
 495     SELECT * FROM getNearFeatures(partition, geometry, maxrank)
 496     WHERE not addr_place_ids @> ARRAY[place_id]
 497     ORDER BY rank_address, isguess asc,
 498              distance *
 499                CASE WHEN rank_address = 16 AND rank_search = 15 THEN 0.2
 500                     WHEN rank_address = 16 AND rank_search = 16 THEN 0.25
 501                     WHEN rank_address = 16 AND rank_search = 18 THEN 0.5
 502                     ELSE 1 END ASC
 503   LOOP
 504     -- Ignore all place nodes that do not fit in a lower level boundary.
 505     CONTINUE WHEN location.isguess
 506                   and current_boundary is not NULL
 507                   and not ST_Contains(current_boundary, location.centroid);
 508
 509     -- If this is the first item in the rank, then assume it is the address.
 510     location_isaddress := not address_havelevel[location.rank_address];
 511
 512     -- Further sanity checks to ensure that the address forms a sane hierarchy.
 513     IF location_isaddress THEN
 514       IF location.isguess and current_node_area is not NULL THEN
 515         location_isaddress := ST_Contains(current_node_area, location.centroid);
 516       END IF;
 517       IF not location.isguess and current_boundary is not NULL
 518          and location.rank_address != 11 AND location.rank_address != 5 THEN
 519         location_isaddress := ST_Contains(current_boundary, location.centroid);
 520       END IF;
 521     END IF;
 522
 523     IF location_isaddress THEN
 524       address_havelevel[location.rank_address] := true;
 525       parent_place_id := location.place_id;
 526
 527       -- Set postcode if we have one.
 528       -- (Returned will be the highest ranking one.)
 529       IF location.postcode is not NULL THEN
 530         postcode = location.postcode;
 531       END IF;
 532
 533       -- Recompute the areas we need for hierarchy sanity checks.
 534       IF location.rank_address != 11 AND location.rank_address != 5 THEN
 535         IF location.isguess THEN
 536           current_node_area := place_node_fuzzy_area(location.centroid,
 537                                                      location.rank_search);
 538         ELSE
 539           current_node_area := NULL;
 540           SELECT p.geometry FROM placex p
 541               WHERE p.place_id = location.place_id INTO current_boundary;
 542         END IF;
 543       END IF;
 544     END IF;
 545
 546     -- Add it to the list of search terms
 547     {% if not db.reverse_only %}
 548       nameaddress_vector := array_merge(nameaddress_vector,
 549                                         location.keywords::integer[]);
 550     {% endif %}
 551
 552     INSERT INTO place_addressline (place_id, address_place_id, fromarea,
 553                                      isaddress, distance, cached_rank_address)
 554         VALUES (obj_place_id, location.place_id, not location.isguess,
 555                 location_isaddress, location.distance, location.rank_address);
 556   END LOOP;
 557 END;
 558 $$
 559 LANGUAGE plpgsql;
 560
 561
 562 CREATE OR REPLACE FUNCTION placex_insert()
 563   RETURNS TRIGGER
 564   AS $$
 565 DECLARE
 566   postcode TEXT;
 567   result BOOLEAN;
 568   is_area BOOLEAN;
 569   country_code VARCHAR(2);
 570   diameter FLOAT;
 571   classtable TEXT;
 572 BEGIN
 573   {% if debug %}RAISE WARNING '% % % %',NEW.osm_type,NEW.osm_id,NEW.class,NEW.type;{% endif %}
 574
 575   NEW.place_id := nextval('seq_place');
 576   NEW.indexed_status := 1; --STATUS_NEW
 577
 578   NEW.centroid := ST_PointOnSurface(NEW.geometry);
 579   NEW.country_code := lower(get_country_code(NEW.centroid));
 580
 581   NEW.partition := get_partition(NEW.country_code);
 582   NEW.geometry_sector := geometry_sector(NEW.partition, NEW.centroid);
 583
 584   IF NEW.osm_type = 'X' THEN
 585     -- E'X'ternal records should already be in the right format so do nothing
 586   ELSE
 587     is_area := ST_GeometryType(NEW.geometry) IN ('ST_Polygon','ST_MultiPolygon');
 588
 589     IF NEW.class in ('place','boundary')
 590        AND NEW.type in ('postcode','postal_code')
 591     THEN
 592       IF NEW.address IS NULL OR NOT NEW.address ? 'postcode' THEN
 593           -- most likely just a part of a multipolygon postcode boundary, throw it away
 594           RETURN NULL;
 595       END IF;
 596
 597       NEW.name := hstore('ref', NEW.address->'postcode');
 598
 599     ELSEIF NEW.class = 'highway' AND is_area AND NEW.name is null
 600            AND NEW.extratags ? 'area' AND NEW.extratags->'area' = 'yes'
 601     THEN
 602         RETURN NULL;
 603     ELSEIF NEW.class = 'boundary' AND NOT is_area
 604     THEN
 605         RETURN NULL;
 606     ELSEIF NEW.class = 'boundary' AND NEW.type = 'administrative'
 607            AND NEW.admin_level <= 4 AND NEW.osm_type = 'W'
 608     THEN
 609         RETURN NULL;
 610     END IF;
 611
 612     SELECT * INTO NEW.rank_search, NEW.rank_address
 613       FROM compute_place_rank(NEW.country_code,
 614                               CASE WHEN is_area THEN 'A' ELSE NEW.osm_type END,
 615                               NEW.class, NEW.type, NEW.admin_level,
 616                               (NEW.extratags->'capital') = 'yes',
 617                               NEW.address->'postcode');
 618
 619     -- a country code make no sense below rank 4 (country)
 620     IF NEW.rank_search < 4 THEN
 621       NEW.country_code := NULL;
 622     END IF;
 623
 624   END IF;
 625
 626   {% if debug %}RAISE WARNING 'placex_insert:END: % % % %',NEW.osm_type,NEW.osm_id,NEW.class,NEW.type;{% endif %}
 627
 628 {% if not disable_diff_updates %}
 629   -- The following is not needed until doing diff updates, and slows the main index process down
 630
 631   IF NEW.rank_address > 0 THEN
 632     IF (ST_GeometryType(NEW.geometry) in ('ST_Polygon','ST_MultiPolygon') AND ST_IsValid(NEW.geometry)) THEN
 633       -- Performance: We just can't handle re-indexing for country level changes
 634       IF st_area(NEW.geometry) < 1 THEN
 635         -- mark items within the geometry for re-indexing
 636   --    RAISE WARNING 'placex poly insert: % % % %',NEW.osm_type,NEW.osm_id,NEW.class,NEW.type;
 637
 638         UPDATE placex SET indexed_status = 2
 639          WHERE ST_Intersects(NEW.geometry, placex.geometry)
 640                and indexed_status = 0
 641                and ((rank_address = 0 and rank_search > NEW.rank_address)
 642                     or rank_address > NEW.rank_address
 643                     or (class = 'place' and osm_type = 'N')
 644                    )
 645                and (rank_search < 28
 646                     or name is not null
 647                     or (NEW.rank_address >= 16 and address ? 'place'));
 648       END IF;
 649     ELSE
 650       -- mark nearby items for re-indexing, where 'nearby' depends on the features rank_search and is a complete guess :(
 651       diameter := update_place_diameter(NEW.rank_search);
 652       IF diameter > 0 THEN
 653   --      RAISE WARNING 'placex point insert: % % % % %',NEW.osm_type,NEW.osm_id,NEW.class,NEW.type,diameter;
 654         IF NEW.rank_search >= 26 THEN
 655           -- roads may cause reparenting for >27 rank places
 656           update placex set indexed_status = 2 where indexed_status = 0 and rank_search > NEW.rank_search and ST_DWithin(placex.geometry, NEW.geometry, diameter);
 657           -- reparenting also for OSM Interpolation Lines (and for Tiger?)
 658           update location_property_osmline set indexed_status = 2 where indexed_status = 0 and startnumber is not null and ST_DWithin(location_property_osmline.linegeo, NEW.geometry, diameter);
 659         ELSEIF NEW.rank_search >= 16 THEN
 660           -- up to rank 16, street-less addresses may need reparenting
 661           update placex set indexed_status = 2 where indexed_status = 0 and rank_search > NEW.rank_search and ST_DWithin(placex.geometry, NEW.geometry, diameter) and (rank_search < 28 or name is not null or address ? 'place');
 662         ELSE
 663           -- for all other places the search terms may change as well
 664           update placex set indexed_status = 2 where indexed_status = 0 and rank_search > NEW.rank_search and ST_DWithin(placex.geometry, NEW.geometry, diameter) and (rank_search < 28 or name is not null);
 665         END IF;
 666       END IF;
 667     END IF;
 668   END IF;
 669
 670
 671    -- add to tables for special search
 672    -- Note: won't work on initial import because the classtype tables
 673    -- do not yet exist. It won't hurt either.
 674   classtable := 'place_classtype_' || NEW.class || '_' || NEW.type;
 675   SELECT count(*)>0 FROM pg_tables WHERE tablename = classtable and schemaname = current_schema() INTO result;
 676   IF result THEN
 677     EXECUTE 'INSERT INTO ' || classtable::regclass || ' (place_id, centroid) VALUES ($1,$2)'
 678     USING NEW.place_id, ST_Centroid(NEW.geometry);
 679   END IF;
 680
 681 {% endif %} -- not disable_diff_updates
 682
 683   RETURN NEW;
 684
 685 END;
 686 $$
 687 LANGUAGE plpgsql;
 688
 689 CREATE OR REPLACE FUNCTION placex_update()
 690   RETURNS TRIGGER
 691   AS $$
 692 DECLARE
 693   i INTEGER;
 694   location RECORD;
 695   relation_members TEXT[];
 696
 697   geom GEOMETRY;
 698   parent_address_level SMALLINT;
 699   place_address_level SMALLINT;
 700
 701   max_rank SMALLINT;
 702
 703   name_vector INTEGER[];
 704   nameaddress_vector INTEGER[];
 705   addr_nameaddress_vector INTEGER[];
 706
 707   linked_place BIGINT;
 708
 709   linked_node_id BIGINT;
 710   linked_importance FLOAT;
 711   linked_wikipedia TEXT;
 712
 713   is_place_address BOOLEAN;
 714   result BOOLEAN;
 715 BEGIN
 716   -- deferred delete
 717   IF OLD.indexed_status = 100 THEN
 718     {% if debug %}RAISE WARNING 'placex_update delete % %',NEW.osm_type,NEW.osm_id;{% endif %}
 719     delete from placex where place_id = OLD.place_id;
 720     RETURN NULL;
 721   END IF;
 722
 723   IF NEW.indexed_status != 0 OR OLD.indexed_status = 0 THEN
 724     RETURN NEW;
 725   END IF;
 726
 727   {% if debug %}RAISE WARNING 'placex_update % % (%)',NEW.osm_type,NEW.osm_id,NEW.place_id;{% endif %}
 728
 729   NEW.indexed_date = now();
 730
 731   {% if 'search_name' in db.tables %}
 732     DELETE from search_name WHERE place_id = NEW.place_id;
 733   {% endif %}
 734   result := deleteSearchName(NEW.partition, NEW.place_id);
 735   DELETE FROM place_addressline WHERE place_id = NEW.place_id;
 736   result := deleteRoad(NEW.partition, NEW.place_id);
 737   result := deleteLocationArea(NEW.partition, NEW.place_id, NEW.rank_search);
 738   UPDATE placex set linked_place_id = null, indexed_status = 2
 739          where linked_place_id = NEW.place_id;
 740   -- update not necessary for osmline, cause linked_place_id does not exist
 741
 742   NEW.extratags := NEW.extratags - 'linked_place'::TEXT;
 743
 744   -- NEW.linked_place_id contains the precomputed linkee. Save this and restore
 745   -- the previous link status.
 746   linked_place := NEW.linked_place_id;
 747   NEW.linked_place_id := OLD.linked_place_id;
 748
 749   IF NEW.linked_place_id is not null THEN
 750     NEW.token_info := null;
 751     {% if debug %}RAISE WARNING 'place already linked to %', OLD.linked_place_id;{% endif %}
 752     RETURN NEW;
 753   END IF;
 754
 755   -- Postcodes are just here to compute the centroids. They are not searchable
 756   -- unless they are a boundary=postal_code.
 757   -- There was an error in the style so that boundary=postal_code used to be
 758   -- imported as place=postcode. That's why relations are allowed to pass here.
 759   -- This can go away in a couple of versions.
 760   IF NEW.class = 'place'  and NEW.type = 'postcode' and NEW.osm_type != 'R' THEN
 761     NEW.token_info := null;
 762     RETURN NEW;
 763   END IF;
 764
 765   -- Compute a preliminary centroid.
 766   NEW.centroid := ST_PointOnSurface(NEW.geometry);
 767
 768     -- recalculate country and partition
 769   IF NEW.rank_search = 4 AND NEW.address is not NULL AND NEW.address ? 'country' THEN
 770     -- for countries, believe the mapped country code,
 771     -- so that we remain in the right partition if the boundaries
 772     -- suddenly expand.
 773     NEW.country_code := lower(NEW.address->'country');
 774     NEW.partition := get_partition(lower(NEW.country_code));
 775     IF NEW.partition = 0 THEN
 776       NEW.country_code := lower(get_country_code(NEW.centroid));
 777       NEW.partition := get_partition(NEW.country_code);
 778     END IF;
 779   ELSE
 780     IF NEW.rank_search >= 4 THEN
 781       NEW.country_code := lower(get_country_code(NEW.centroid));
 782     ELSE
 783       NEW.country_code := NULL;
 784     END IF;
 785     NEW.partition := get_partition(NEW.country_code);
 786   END IF;
 787   {% if debug %}RAISE WARNING 'Country updated: "%"', NEW.country_code;{% endif %}
 788
 789
 790   -- recompute the ranks, they might change when linking changes
 791   SELECT * INTO NEW.rank_search, NEW.rank_address
 792     FROM compute_place_rank(NEW.country_code,
 793                             CASE WHEN ST_GeometryType(NEW.geometry)
 794                                         IN ('ST_Polygon','ST_MultiPolygon')
 795                             THEN 'A' ELSE NEW.osm_type END,
 796                             NEW.class, NEW.type, NEW.admin_level,
 797                             (NEW.extratags->'capital') = 'yes',
 798                             NEW.address->'postcode');
 799   -- We must always increase the address level relative to the admin boundary.
 800   IF NEW.class = 'boundary' and NEW.type = 'administrative'
 801      and NEW.osm_type = 'R' and NEW.rank_address > 0
 802   THEN
 803     -- First, check that admin boundaries do not overtake each other rank-wise.
 804     parent_address_level := 3;
 805     FOR location IN
 806       SELECT rank_address,
 807              (CASE WHEN extratags ? 'wikidata' and NEW.extratags ? 'wikidata'
 808                         and extratags->'wikidata' = NEW.extratags->'wikidata'
 809                    THEN ST_Equals(geometry, NEW.geometry)
 810                    ELSE false END) as is_same
 811       FROM placex
 812       WHERE osm_type = 'R' and class = 'boundary' and type = 'administrative'
 813             and admin_level < NEW.admin_level and admin_level > 3
 814             and rank_address > 0
 815             and geometry && NEW.centroid and _ST_Covers(geometry, NEW.centroid)
 816       ORDER BY admin_level desc LIMIT 1
 817     LOOP
 818       IF location.is_same THEN
 819         -- Looks like the same boundary is replicated on multiple admin_levels.
 820         -- Usual tagging in Poland. Remove our boundary from addresses.
 821         NEW.rank_address := 0;
 822       ELSE
 823         parent_address_level := location.rank_address;
 824         IF location.rank_address >= NEW.rank_address THEN
 825           IF location.rank_address >= 24 THEN
 826             NEW.rank_address := 25;
 827           ELSE
 828             NEW.rank_address := location.rank_address + 2;
 829           END IF;
 830         END IF;
 831       END IF;
 832     END LOOP;
 833
 834     IF NEW.rank_address > 9 THEN
 835         -- Second check that the boundary is not completely contained in a
 836         -- place area with a higher address rank
 837         FOR location IN
 838           SELECT rank_address FROM placex
 839           WHERE class = 'place' and rank_address < 24
 840                 and rank_address > NEW.rank_address
 841                 and geometry && NEW.geometry
 842                 and geometry ~ NEW.geometry -- needed because ST_Relate does not do bbox cover test
 843                 and ST_Relate(geometry, NEW.geometry, 'T*T***FF*') -- contains but not equal
 844           ORDER BY rank_address desc LIMIT 1
 845         LOOP
 846           NEW.rank_address := location.rank_address + 2;
 847         END LOOP;
 848     END IF;
 849   ELSEIF NEW.class = 'place' and NEW.osm_type = 'N'
 850      and NEW.rank_address between 16 and 23
 851   THEN
 852     -- If a place node is contained in a admin boundary with the same address level
 853     -- and has not been linked, then make the node a subpart by increasing the
 854     -- address rank (city level and above).
 855     FOR location IN
 856         SELECT rank_address FROM placex
 857         WHERE osm_type = 'R' and class = 'boundary' and type = 'administrative'
 858               and rank_address = NEW.rank_address
 859               and geometry && NEW.centroid and _ST_Covers(geometry, NEW.centroid)
 860         LIMIT 1
 861     LOOP
 862       NEW.rank_address = NEW.rank_address + 2;
 863     END LOOP;
 864   ELSE
 865     parent_address_level := 3;
 866   END IF;
 867
 868   NEW.housenumber := token_normalized_housenumber(NEW.token_info);
 869
 870   NEW.postcode := null;
 871
 872   -- waterway ways are linked when they are part of a relation and have the same class/type
 873   IF NEW.osm_type = 'R' and NEW.class = 'waterway' THEN
 874       FOR relation_members IN select members from planet_osm_rels r where r.id = NEW.osm_id and r.parts != array[]::bigint[]
 875       LOOP
 876           FOR i IN 1..array_upper(relation_members, 1) BY 2 LOOP
 877               IF relation_members[i+1] in ('', 'main_stream', 'side_stream') AND substring(relation_members[i],1,1) = 'w' THEN
 878                 {% if debug %}RAISE WARNING 'waterway parent %, child %/%', NEW.osm_id, i, relation_members[i];{% endif %}
 879                 FOR linked_node_id IN SELECT place_id FROM placex
 880                   WHERE osm_type = 'W' and osm_id = substring(relation_members[i],2,200)::bigint
 881                   and class = NEW.class and type in ('river', 'stream', 'canal', 'drain', 'ditch')
 882                   and ( relation_members[i+1] != 'side_stream' or NEW.name->'name' = name->'name')
 883                 LOOP
 884                   UPDATE placex SET linked_place_id = NEW.place_id WHERE place_id = linked_node_id;
 885                   {% if 'search_name' in db.tables %}
 886                     DELETE FROM search_name WHERE place_id = linked_node_id;
 887                   {% endif %}
 888                 END LOOP;
 889               END IF;
 890           END LOOP;
 891       END LOOP;
 892       {% if debug %}RAISE WARNING 'Waterway processed';{% endif %}
 893   END IF;
 894
 895   NEW.importance := null;
 896   SELECT wikipedia, importance
 897     FROM compute_importance(NEW.extratags, NEW.country_code, NEW.osm_type, NEW.osm_id)
 898     INTO NEW.wikipedia,NEW.importance;
 899
 900 {% if debug %}RAISE WARNING 'Importance computed from wikipedia: %', NEW.importance;{% endif %}
 901
 902   -- ---------------------------------------------------------------------------
 903   -- For low level elements we inherit from our parent road
 904   IF NEW.rank_search > 27 THEN
 905
 906     {% if debug %}RAISE WARNING 'finding street for % %', NEW.osm_type, NEW.osm_id;{% endif %}
 907     NEW.parent_place_id := null;
 908     is_place_address := coalesce(not NEW.address ? 'street' and NEW.address ? 'place', FALSE);
 909
 910     -- We have to find our parent road.
 911     NEW.parent_place_id := find_parent_for_poi(NEW.osm_type, NEW.osm_id,
 912                                                NEW.partition,
 913                                                ST_Envelope(NEW.geometry),
 914                                                NEW.token_info,
 915                                                is_place_address);
 916
 917     -- If we found the road take a shortcut here.
 918     -- Otherwise fall back to the full address getting method below.
 919     IF NEW.parent_place_id is not null THEN
 920
 921       -- Get the details of the parent road
 922       SELECT p.country_code, p.postcode, p.name FROM placex p
 923        WHERE p.place_id = NEW.parent_place_id INTO location;
 924
 925       IF is_place_address THEN
 926         -- Check if the addr:place tag is part of the parent name
 927         SELECT count(*) INTO i
 928           FROM svals(location.name) AS pname WHERE pname = NEW.address->'place';
 929         IF i = 0 THEN
 930           NEW.address = NEW.address || hstore('_unlisted_place', NEW.address->'place');
 931         END IF;
 932       END IF;
 933
 934       NEW.country_code := location.country_code;
 935       {% if debug %}RAISE WARNING 'Got parent details from search name';{% endif %}
 936
 937       -- determine postcode
 938       NEW.postcode := coalesce(token_normalized_postcode(NEW.address->'postcode'),
 939                                location.postcode,
 940                                get_nearest_postcode(NEW.country_code, NEW.centroid));
 941
 942       IF NEW.name is not NULL THEN
 943           NEW.name := add_default_place_name(NEW.country_code, NEW.name);
 944       END IF;
 945
 946       {% if not db.reverse_only %}
 947       IF NEW.name is not NULL OR NEW.address is not NULL THEN
 948         SELECT * INTO name_vector, nameaddress_vector
 949           FROM create_poi_search_terms(NEW.place_id,
 950                                        NEW.partition, NEW.parent_place_id,
 951                                        is_place_address, NEW.country_code,
 952                                        NEW.token_info, NEW.centroid);
 953
 954         IF array_length(name_vector, 1) is not NULL THEN
 955           INSERT INTO search_name (place_id, search_rank, address_rank,
 956                                    importance, country_code, name_vector,
 957                                    nameaddress_vector, centroid)
 958                  VALUES (NEW.place_id, NEW.rank_search, NEW.rank_address,
 959                          NEW.importance, NEW.country_code, name_vector,
 960                          nameaddress_vector, NEW.centroid);
 961           {% if debug %}RAISE WARNING 'Place added to search table';{% endif %}
 962         END IF;
 963       END IF;
 964       {% endif %}
 965
 966       NEW.token_info := token_strip_info(NEW.token_info);
 967       -- If the address was inherited from a surrounding building,
 968       -- do not add it permanently to the table.
 969       IF NEW.address ? '_inherited' THEN
 970         IF NEW.address ? '_unlisted_place' THEN
 971           NEW.address := hstore('_unlisted_place', NEW.address->'_unlisted_place');
 972         ELSE
 973           NEW.address := null;
 974         END IF;
 975       END IF;
 976
 977       RETURN NEW;
 978     END IF;
 979
 980   END IF;
 981
 982   -- ---------------------------------------------------------------------------
 983   -- Full indexing
 984   {% if debug %}RAISE WARNING 'Using full index mode for % %', NEW.osm_type, NEW.osm_id;{% endif %}
 985   IF linked_place is not null THEN
 986     SELECT * INTO location FROM placex WHERE place_id = linked_place;
 987
 988     {% if debug %}RAISE WARNING 'Linked %', location;{% endif %}
 989
 990     -- Use the linked point as the centre point of the geometry,
 991     -- but only if it is within the area of the boundary.
 992     geom := coalesce(location.centroid, ST_Centroid(location.geometry));
 993     IF geom is not NULL AND ST_Within(geom, NEW.geometry) THEN
 994         NEW.centroid := geom;
 995     END IF;
 996
 997     {% if debug %}RAISE WARNING 'parent address: % rank address: %', parent_address_level, location.rank_address;{% endif %}
 998     IF location.rank_address > parent_address_level
 999        and location.rank_address < 26
1000     THEN
1001       NEW.rank_address := location.rank_address;
1002     END IF;
1003
1004     -- merge in extra tags
1005     NEW.extratags := hstore('linked_' || location.class, location.type)
1006                      || coalesce(location.extratags, ''::hstore)
1007                      || coalesce(NEW.extratags, ''::hstore);
1008
1009     -- mark the linked place (excludes from search results)
1010     UPDATE placex set linked_place_id = NEW.place_id
1011       WHERE place_id = location.place_id;
1012     -- ensure that those places are not found anymore
1013     {% if 'search_name' in db.tables %}
1014       DELETE FROM search_name WHERE place_id = location.place_id;
1015     {% endif %}
1016     PERFORM deleteLocationArea(NEW.partition, location.place_id, NEW.rank_search);
1017
1018     SELECT wikipedia, importance
1019       FROM compute_importance(location.extratags, NEW.country_code,
1020                               'N', location.osm_id)
1021       INTO linked_wikipedia,linked_importance;
1022
1023     -- Use the maximum importance if one could be computed from the linked object.
1024     IF linked_importance is not null AND
1025        (NEW.importance is null or NEW.importance < linked_importance)
1026     THEN
1027       NEW.importance = linked_importance;
1028     END IF;
1029   ELSE
1030     -- No linked place? As a last resort check if the boundary is tagged with
1031     -- a place type and adapt the rank address.
1032     IF NEW.rank_address > 0 and NEW.extratags ? 'place' THEN
1033       SELECT address_rank INTO place_address_level
1034         FROM compute_place_rank(NEW.country_code, 'A', 'place',
1035                                 NEW.extratags->'place', 0::SMALLINT, False, null);
1036       IF place_address_level > parent_address_level and
1037          place_address_level < 26 THEN
1038         NEW.rank_address := place_address_level;
1039       END IF;
1040     END IF;
1041   END IF;
1042
1043   IF NEW.admin_level = 2
1044      AND NEW.class = 'boundary' AND NEW.type = 'administrative'
1045      AND NEW.country_code IS NOT NULL AND NEW.osm_type = 'R'
1046   THEN
1047     -- Update the list of country names. Adding an additional sanity
1048     -- check here: make sure the country does overlap with the area where
1049     -- we expect it to be as per static country grid.
1050     -- FOR location IN
1051     --  SELECT country_code FROM country_osm_grid
1052     --   WHERE ST_Covers(geometry, NEW.centroid) and country_code = NEW.country_code
1053     --   LIMIT 1
1054     -- LOOP
1055     --  {% if debug %}RAISE WARNING 'Updating names for country '%' with: %', NEW.country_code, NEW.name;{% endif %}
1056     --  UPDATE country_name SET name = name || NEW.name WHERE country_code = NEW.country_code;
1057     -- END LOOP;
1058   END IF;
1059
1060   -- For linear features we need the full geometry for determining the address
1061   -- because they may go through several administrative entities. Otherwise use
1062   -- the centroid for performance reasons.
1063   IF ST_GeometryType(NEW.geometry) in ('ST_LineString', 'ST_MultiLineString') THEN
1064     geom := NEW.geometry;
1065   ELSE
1066     geom := NEW.centroid;
1067   END IF;
1068
1069   IF NEW.rank_address = 0 THEN
1070     max_rank := geometry_to_rank(NEW.rank_search, NEW.geometry, NEW.country_code);
1071     -- Rank 0 features may also span multiple administrative areas (e.g. lakes)
1072     -- so use the geometry here too. Just make sure the areas don't become too
1073     -- large.
1074     IF NEW.class = 'natural' or max_rank > 10 THEN
1075       geom := NEW.geometry;
1076     END IF;
1077   ELSEIF NEW.rank_address > 25 THEN
1078     max_rank := 25;
1079   ELSE
1080     max_rank := NEW.rank_address;
1081   END IF;
1082
1083   SELECT * FROM insert_addresslines(NEW.place_id, NEW.partition, max_rank,
1084                                     NEW.token_info, geom, NEW.country_code)
1085     INTO NEW.parent_place_id, NEW.postcode, nameaddress_vector;
1086
1087   {% if debug %}RAISE WARNING 'RETURN insert_addresslines: %, %, %', NEW.parent_place_id, NEW.postcode, nameaddress_vector;{% endif %}
1088
1089   NEW.postcode := coalesce(token_normalized_postcode(NEW.address->'postcode'),
1090                            NEW.postcode);
1091
1092   -- if we have a name add this to the name search table
1093   IF NEW.name IS NOT NULL THEN
1094     -- Initialise the name vector using our name
1095     NEW.name := add_default_place_name(NEW.country_code, NEW.name);
1096     name_vector := token_get_name_search_tokens(NEW.token_info);
1097
1098     IF NEW.rank_search <= 25 and NEW.rank_address > 0 THEN
1099       result := add_location(NEW.place_id, NEW.country_code, NEW.partition,
1100                              name_vector, NEW.rank_search, NEW.rank_address,
1101                              NEW.postcode, NEW.geometry, NEW.centroid);
1102       {% if debug %}RAISE WARNING 'added to location (full)';{% endif %}
1103     END IF;
1104
1105     IF NEW.rank_search between 26 and 27 and NEW.class = 'highway' THEN
1106       result := insertLocationRoad(NEW.partition, NEW.place_id, NEW.country_code, NEW.geometry);
1107       {% if debug %}RAISE WARNING 'insert into road location table (full)';{% endif %}
1108     END IF;
1109
1110     IF NEW.rank_address between 16 and 27 THEN
1111       result := insertSearchName(NEW.partition, NEW.place_id,
1112                                  token_get_name_match_tokens(NEW.token_info),
1113                                  NEW.rank_search, NEW.rank_address, NEW.geometry);
1114     END IF;
1115     {% if debug %}RAISE WARNING 'added to search name (full)';{% endif %}
1116
1117     {% if not db.reverse_only %}
1118         INSERT INTO search_name (place_id, search_rank, address_rank,
1119                                  importance, country_code, name_vector,
1120                                  nameaddress_vector, centroid)
1121                VALUES (NEW.place_id, NEW.rank_search, NEW.rank_address,
1122                        NEW.importance, NEW.country_code, name_vector,
1123                        nameaddress_vector, NEW.centroid);
1124     {% endif %}
1125   END IF;
1126
1127   IF NEW.postcode is null AND NEW.rank_search > 8 THEN
1128     NEW.postcode := get_nearest_postcode(NEW.country_code, NEW.geometry);
1129   END IF;
1130
1131   {% if debug %}RAISE WARNING 'place update % % finsihed.', NEW.osm_type, NEW.osm_id;{% endif %}
1132
1133   NEW.token_info := token_strip_info(NEW.token_info);
1134   RETURN NEW;
1135 END;
1136 $$
1137 LANGUAGE plpgsql;
1138
1139
1140 CREATE OR REPLACE FUNCTION placex_delete()
1141   RETURNS TRIGGER
1142   AS $$
1143 DECLARE
1144   b BOOLEAN;
1145   classtable TEXT;
1146 BEGIN
1147   -- RAISE WARNING 'placex_delete % %',OLD.osm_type,OLD.osm_id;
1148
1149   IF OLD.linked_place_id is null THEN
1150     update placex set linked_place_id = null, indexed_status = 2 where linked_place_id = OLD.place_id and indexed_status = 0;
1151     {% if debug %}RAISE WARNING 'placex_delete:01 % %',OLD.osm_type,OLD.osm_id;{% endif %}
1152     update placex set linked_place_id = null where linked_place_id = OLD.place_id;
1153     {% if debug %}RAISE WARNING 'placex_delete:02 % %',OLD.osm_type,OLD.osm_id;{% endif %}
1154   ELSE
1155     update placex set indexed_status = 2 where place_id = OLD.linked_place_id and indexed_status = 0;
1156   END IF;
1157
1158   IF OLD.rank_address < 30 THEN
1159
1160     -- mark everything linked to this place for re-indexing
1161     {% if debug %}RAISE WARNING 'placex_delete:03 % %',OLD.osm_type,OLD.osm_id;{% endif %}
1162     UPDATE placex set indexed_status = 2 from place_addressline where address_place_id = OLD.place_id
1163       and placex.place_id = place_addressline.place_id and indexed_status = 0 and place_addressline.isaddress;
1164
1165     {% if debug %}RAISE WARNING 'placex_delete:04 % %',OLD.osm_type,OLD.osm_id;{% endif %}
1166     DELETE FROM place_addressline where address_place_id = OLD.place_id;
1167
1168     {% if debug %}RAISE WARNING 'placex_delete:05 % %',OLD.osm_type,OLD.osm_id;{% endif %}
1169     b := deleteRoad(OLD.partition, OLD.place_id);
1170
1171     {% if debug %}RAISE WARNING 'placex_delete:06 % %',OLD.osm_type,OLD.osm_id;{% endif %}
1172     update placex set indexed_status = 2 where parent_place_id = OLD.place_id and indexed_status = 0;
1173     {% if debug %}RAISE WARNING 'placex_delete:07 % %',OLD.osm_type,OLD.osm_id;{% endif %}
1174     -- reparenting also for OSM Interpolation Lines (and for Tiger?)
1175     update location_property_osmline set indexed_status = 2 where indexed_status = 0 and parent_place_id = OLD.place_id;
1176
1177   END IF;
1178
1179   {% if debug %}RAISE WARNING 'placex_delete:08 % %',OLD.osm_type,OLD.osm_id;{% endif %}
1180
1181   IF OLD.rank_address < 26 THEN
1182     b := deleteLocationArea(OLD.partition, OLD.place_id, OLD.rank_search);
1183   END IF;
1184
1185   {% if debug %}RAISE WARNING 'placex_delete:09 % %',OLD.osm_type,OLD.osm_id;{% endif %}
1186
1187   IF OLD.name is not null THEN
1188     {% if 'search_name' in db.tables %}
1189       DELETE from search_name WHERE place_id = OLD.place_id;
1190     {% endif %}
1191     b := deleteSearchName(OLD.partition, OLD.place_id);
1192   END IF;
1193
1194   {% if debug %}RAISE WARNING 'placex_delete:10 % %',OLD.osm_type,OLD.osm_id;{% endif %}
1195
1196   DELETE FROM place_addressline where place_id = OLD.place_id;
1197
1198   {% if debug %}RAISE WARNING 'placex_delete:11 % %',OLD.osm_type,OLD.osm_id;{% endif %}
1199
1200   -- remove from tables for special search
1201   classtable := 'place_classtype_' || OLD.class || '_' || OLD.type;
1202   SELECT count(*)>0 FROM pg_tables WHERE tablename = classtable and schemaname = current_schema() INTO b;
1203   IF b THEN
1204     EXECUTE 'DELETE FROM ' || classtable::regclass || ' WHERE place_id = $1' USING OLD.place_id;
1205   END IF;
1206
1207   {% if debug %}RAISE WARNING 'placex_delete:12 % %',OLD.osm_type,OLD.osm_id;{% endif %}
1208
1209   RETURN OLD;
1210
1211 END;
1212 $$
1213 LANGUAGE plpgsql;